1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ByteArray.size_extract
File: .lake/packages/batteries/Batteries/Data/ByteArray.lean

tactic: simp [size]
state_before: a : ByteArray
start stop : Nat
⊢ (a.extract start stop).size = min stop a.size - start
state_after: no goals
Theorem: Matroid.Base.card_eq_card_of_base
File: Mathlib/Data/Matroid/Basic.lean

tactic: rw [M.base_exchange.encard_base_eq hB₁ hB₂]
state_before: α : Type u_1
M : Matroid α
B₁ B₂ : Set α
hB₁ : M.Base B₁
hB₂ : M.Base B₂
⊢ B₁.encard = B₂.encard
state_after: no goals
Theorem: Subgroup.card_eq_card_quotient_mul_card_subgroup
File: Mathlib/GroupTheory/Coset.lean

tactic: rw [← Nat.card_prod]
state_before: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card (α ⧸ s) * Nat.card ↥s
state_after: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card ((α ⧸ s) × ↥s)

tactic: exact Nat.card_congr Subgroup.groupEquivQuotientProdSubgroup
state_before: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card ((α ⧸ s) × ↥s)
state_after: no goals
Theorem: PrimeSpectrum.basicOpen_mul_le_right
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [basicOpen_mul f g]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f g : R
⊢ basicOpen (f * g) ≤ basicOpen g
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f g : R
⊢ basicOpen f ⊓ basicOpen g ≤ basicOpen g

tactic: exact inf_le_right
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f g : R
⊢ basicOpen f ⊓ basicOpen g ≤ basicOpen g
state_after: no goals
Theorem: IsSimpleModule.annihilator_isMaximal
File: Mathlib/RingTheory/SimpleModule.lean

tactic: have ⟨I, max, ⟨e⟩⟩ := isSimpleModule_iff_quot_maximal.mp simple
state_before: ι : Type u_1
R✝ : Type u_2
S : Type u_3
inst✝⁷ : Ring R✝
inst✝⁶ : Ring S
M : Type u_4
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R✝ M
m : Submodule R✝ M
N : Type u_5
inst✝³ : AddCommGroup N
inst✝² : Module R✝ N
R : Type u_6
inst✝¹ : CommRing R
inst✝ : Module R M
simple : IsSimpleModule R M
⊢ (Module.annihilator R M).IsMaximal
state_after: ι : Type u_1
R✝ : Type u_2
S : Type u_3
inst✝⁷ : Ring R✝
inst✝⁶ : Ring S
M : Type u_4
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R✝ M
m : Submodule R✝ M
N : Type u_5
inst✝³ : AddCommGroup N
inst✝² : Module R✝ N
R : Type u_6
inst✝¹ : CommRing R
inst✝ : Module R M
simple : IsSimpleModule R M
I : Ideal R
max : I.IsMaximal
e : M ≃ₗ[R] R ⧸ I
⊢ (Module.annihilator R M).IsMaximal

tactic: rwa [e.annihilator_eq, I.annihilator_quotient]
state_before: ι : Type u_1
R✝ : Type u_2
S : Type u_3
inst✝⁷ : Ring R✝
inst✝⁶ : Ring S
M : Type u_4
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R✝ M
m : Submodule R✝ M
N : Type u_5
inst✝³ : AddCommGroup N
inst✝² : Module R✝ N
R : Type u_6
inst✝¹ : CommRing R
inst✝ : Module R M
simple : IsSimpleModule R M
I : Ideal R
max : I.IsMaximal
e : M ≃ₗ[R] R ⧸ I
⊢ (Module.annihilator R M).IsMaximal
state_after: no goals
Theorem: Finmap.lookup_insert_of_ne
File: Mathlib/Data/Finmap.lean

tactic: simp only [insert_toFinmap, lookup_toFinmap, lookup_insert_ne h]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
s✝ : Finmap β
h : a' ≠ a
s : AList β
⊢ lookup a' (insert a b ⟦s⟧) = lookup a' ⟦s⟧
state_after: no goals
Theorem: MulAction.stabilizer_finset_singleton
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

tactic: ext
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
⊢ stabilizer G {b} = stabilizer G b
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
x✝ : G
⊢ x✝ ∈ stabilizer G {b} ↔ x✝ ∈ stabilizer G b

tactic: simp
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
x✝ : G
⊢ x✝ ∈ stabilizer G {b} ↔ x✝ ∈ stabilizer G b
state_after: no goals
Theorem: continuous_pow
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: simpa using continuous_const
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
⊢ Continuous fun a => a ^ 0
state_after: no goals

tactic: simp only [pow_succ']
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
k : ℕ
⊢ Continuous fun a => a ^ (k + 1)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
k : ℕ
⊢ Continuous fun a => a * a ^ k

tactic: exact continuous_id.mul (continuous_pow _)
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
k : ℕ
⊢ Continuous fun a => a * a ^ k
state_after: no goals
Theorem: CategoryTheory.rightDistributor_inv
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: ext
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X : C
⊢ (rightDistributor f X).inv = ∑ j : J, biproduct.π (fun j => f j ⊗ X) j ≫ biproduct.ι f j ▷ X
state_after: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X : C
j✝ : J
⊢ biproduct.ι (fun j => f j ⊗ X) j✝ ≫ (rightDistributor f X).inv =
    biproduct.ι (fun j => f j ⊗ X) j✝ ≫ ∑ j : J, biproduct.π (fun j => f j ⊗ X) j ≫ biproduct.ι f j ▷ X

tactic: dsimp [rightDistributor, Functor.mapBiproduct, Functor.mapBicone]
state_before: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X : C
j✝ : J
⊢ biproduct.ι (fun j => f j ⊗ X) j✝ ≫ (rightDistributor f X).inv =
    biproduct.ι (fun j => f j ⊗ X) j✝ ≫ ∑ j : J, biproduct.π (fun j => f j ⊗ X) j ≫ biproduct.ι f j ▷ X
state_after: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X : C
j✝ : J
⊢ (biproduct.ι (fun j => f j ⊗ X) j✝ ≫ biproduct.desc fun j => biproduct.ι f j ▷ X) =
    biproduct.ι (fun j => f j ⊗ X) j✝ ≫ ∑ j : J, biproduct.π (fun j => f j ⊗ X) j ≫ biproduct.ι f j ▷ X

tactic: simp only [biproduct.ι_desc, Preadditive.comp_sum, ne_eq, biproduct.ι_π_assoc, dite_comp,
  zero_comp, Finset.sum_dite_eq, Finset.mem_univ, eqToHom_refl, Category.id_comp, ite_true]
state_before: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X : C
j✝ : J
⊢ (biproduct.ι (fun j => f j ⊗ X) j✝ ≫ biproduct.desc fun j => biproduct.ι f j ▷ X) =
    biproduct.ι (fun j => f j ⊗ X) j✝ ≫ ∑ j : J, biproduct.π (fun j => f j ⊗ X) j ≫ biproduct.ι f j ▷ X
state_after: no goals
Theorem: Nat.primeFactors_mul
File: Mathlib/Data/Nat/PrimeFin.lean

tactic: ext
state_before: a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (a * b).primeFactors = a.primeFactors ∪ b.primeFactors
state_after: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ a✝ ∈ (a * b).primeFactors ↔ a✝ ∈ a.primeFactors ∪ b.primeFactors

tactic: simp only [Finset.mem_union, mem_primeFactors_iff_mem_factors, mem_factors_mul ha hb]
state_before: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ a✝ ∈ (a * b).primeFactors ↔ a✝ ∈ a.primeFactors ∪ b.primeFactors
state_after: no goals
Theorem: descPochhammer_eval_eq_ascPochhammer
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: induction n with
| zero => rw [descPochhammer_zero, eval_one, ascPochhammer_zero, eval_one]
| succ n ih =>
  rw [Nat.cast_succ, sub_add, add_sub_cancel_right, descPochhammer_succ_eval, ih,
    ascPochhammer_succ_left, X_mul, eval_mul_X, show (X + 1 : R[X]) =
    (X + 1 : ℕ[X]).map (algebraMap ℕ R) by simp only [Polynomial.map_add, map_X,
    Polynomial.map_one], ascPochhammer_eval_comp, eval₂_add, eval₂_X, eval₂_one]
state_before: R : Type u
inst✝ : Ring R
r : R
n : ℕ
⊢ eval r (descPochhammer R n) = eval (r - ↑n + 1) (ascPochhammer R n)
state_after: no goals

tactic: rw [descPochhammer_zero, eval_one, ascPochhammer_zero, eval_one]
state_before: case zero
R : Type u
inst✝ : Ring R
r : R
⊢ eval r (descPochhammer R 0) = eval (r - ↑0 + 1) (ascPochhammer R 0)
state_after: no goals

tactic: rw [Nat.cast_succ, sub_add, add_sub_cancel_right, descPochhammer_succ_eval, ih,
  ascPochhammer_succ_left, X_mul, eval_mul_X, show (X + 1 : R[X]) =
  (X + 1 : ℕ[X]).map (algebraMap ℕ R) by simp only [Polynomial.map_add, map_X,
  Polynomial.map_one], ascPochhammer_eval_comp, eval₂_add, eval₂_X, eval₂_one]
state_before: case succ
R : Type u
inst✝ : Ring R
r : R
n : ℕ
ih : eval r (descPochhammer R n) = eval (r - ↑n + 1) (ascPochhammer R n)
⊢ eval r (descPochhammer R (n + 1)) = eval (r - ↑(n + 1) + 1) (ascPochhammer R (n + 1))
state_after: no goals

tactic: simp only [Polynomial.map_add, map_X,
Polynomial.map_one]
state_before: R : Type u
inst✝ : Ring R
r : R
n : ℕ
ih : eval r (descPochhammer R n) = eval (r - ↑n + 1) (ascPochhammer R n)
⊢ X + 1 = map (algebraMap ℕ R) (X + 1)
state_after: no goals
Theorem: List.enumFrom_map
File: Mathlib/Data/List/Enum.lean

tactic: induction' l with hd tl IH
state_before: α : Type u_1
β : Type u_2
n : ℕ
l : List α
f : α → β
⊢ enumFrom n (map f l) = map (Prod.map id f) (enumFrom n l)
state_after: case nil
α : Type u_1
β : Type u_2
n : ℕ
f : α → β
⊢ enumFrom n (map f []) = map (Prod.map id f) (enumFrom n [])

case cons
α : Type u_1
β : Type u_2
n : ℕ
f : α → β
hd : α
tl : List α
IH : enumFrom n (map f tl) = map (Prod.map id f) (enumFrom n tl)
⊢ enumFrom n (map f (hd :: tl)) = map (Prod.map id f) (enumFrom n (hd :: tl))

tactic: rfl
state_before: case nil
α : Type u_1
β : Type u_2
n : ℕ
f : α → β
⊢ enumFrom n (map f []) = map (Prod.map id f) (enumFrom n [])
state_after: no goals

tactic: rw [map_cons, enumFrom_cons', enumFrom_cons', map_cons, map_map, IH, map_map]
state_before: case cons
α : Type u_1
β : Type u_2
n : ℕ
f : α → β
hd : α
tl : List α
IH : enumFrom n (map f tl) = map (Prod.map id f) (enumFrom n tl)
⊢ enumFrom n (map f (hd :: tl)) = map (Prod.map id f) (enumFrom n (hd :: tl))
state_after: case cons
α : Type u_1
β : Type u_2
n : ℕ
f : α → β
hd : α
tl : List α
IH : enumFrom n (map f tl) = map (Prod.map id f) (enumFrom n tl)
⊢ (n, f hd) :: map (Prod.map Nat.succ id ∘ Prod.map id f) (enumFrom n tl) =
    Prod.map id f (n, hd) :: map (Prod.map id f ∘ Prod.map Nat.succ id) (enumFrom n tl)

tactic: rfl
state_before: case cons
α : Type u_1
β : Type u_2
n : ℕ
f : α → β
hd : α
tl : List α
IH : enumFrom n (map f tl) = map (Prod.map id f) (enumFrom n tl)
⊢ (n, f hd) :: map (Prod.map Nat.succ id ∘ Prod.map id f) (enumFrom n tl) =
    Prod.map id f (n, hd) :: map (Prod.map id f ∘ Prod.map Nat.succ id) (enumFrom n tl)
state_after: no goals
Theorem: Squarefree.ne_zero
File: Mathlib/Algebra/Squarefree/Basic.lean

tactic: rintro rfl
state_before: R : Type u_1
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
m : R
hm : Squarefree m
⊢ m ≠ 0
state_after: R : Type u_1
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hm : Squarefree 0
⊢ False

tactic: exact not_squarefree_zero hm
state_before: R : Type u_1
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hm : Squarefree 0
⊢ False
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.restrict_lintegral_eq_lintegral_restrict
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [f.restrict_lintegral hs, lintegral_restrict]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ (f.restrict s).lintegral μ = f.lintegral (μ.restrict s)
state_after: no goals
Theorem: isLindelof_singleton
File: Mathlib/Topology/Compactness/Lindelof.lean

tactic: simpa only [principal_singleton] using pure_le_nhds x
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x : X
f : Filter X
hf : f.NeBot
x✝ : CountableInterFilter f
hfa : f ≤ 𝓟 {x}
⊢ 𝓟 {x} ≤ 𝓝 x
state_after: no goals
Theorem: Mathlib.Tactic.Ring.natCast_nat
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
n : ℕ
⊢ ↑n.rawCast = n.rawCast
state_after: no goals
Theorem: Set.finite_iff_bddBelow_bddAbove
File: Mathlib/Order/Interval/Finset/Defs.lean

tactic: obtain (rfl | hs) := s.eq_empty_or_nonempty
state_before: α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
α : Type u_3
s : Set α
inst✝² : Nonempty α
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
⊢ s.Finite ↔ BddBelow s ∧ BddAbove s
state_after: case inl
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
α : Type u_3
inst✝² : Nonempty α
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
⊢ ∅.Finite ↔ BddBelow ∅ ∧ BddAbove ∅

case inr
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
α : Type u_3
s : Set α
inst✝² : Nonempty α
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
hs : s.Nonempty
⊢ s.Finite ↔ BddBelow s ∧ BddAbove s

tactic: exact ⟨fun h ↦ ⟨⟨h.toFinset.inf' ((Finite.toFinset_nonempty h).mpr hs) id,
  fun x hx ↦ Finset.inf'_le id ((Finite.mem_toFinset h).mpr hx)⟩,
  ⟨h.toFinset.sup' ((Finite.toFinset_nonempty h).mpr hs) id, fun x hx ↦ Finset.le_sup' id
  ((Finite.mem_toFinset h).mpr hx)⟩⟩,
  fun ⟨h₀, h₁⟩ ↦ BddBelow.finite_of_bddAbove h₀ h₁⟩
state_before: case inr
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
α : Type u_3
s : Set α
inst✝² : Nonempty α
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
hs : s.Nonempty
⊢ s.Finite ↔ BddBelow s ∧ BddAbove s
state_after: no goals

tactic: simp only [Set.finite_empty, bddBelow_empty, bddAbove_empty, and_self]
state_before: case inl
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
α : Type u_3
inst✝² : Nonempty α
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
⊢ ∅.Finite ↔ BddBelow ∅ ∧ BddAbove ∅
state_after: no goals
Theorem: CategoryTheory.Limits.IsInitial.hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsInitial X
f g : X ⟶ Y
⊢ ∀ (j : Discrete PEmpty.{1}), (asEmptyCocone X).ι.app j ≫ f = (asEmptyCocone X).ι.app j ≫ g
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.superset_covering
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

tactic: apply J.transitive sjx R fun Y f hf => _
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
⊢ R ∈ J.sieves X
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
⊢ ∀ (Y : C) (f : Y ⟶ X), S.arrows f → Sieve.pullback f R ∈ J.sieves Y

tactic: intros Y f hf
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
⊢ ∀ (Y : C) (f : Y ⟶ X), S.arrows f → Sieve.pullback f R ∈ J.sieves Y
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : S.arrows f
⊢ Sieve.pullback f R ∈ J.sieves Y

tactic: apply covering_of_eq_top
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : S.arrows f
⊢ Sieve.pullback f R ∈ J.sieves Y
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : S.arrows f
⊢ Sieve.pullback f R = ⊤

tactic: rw [← top_le_iff, ← S.pullback_eq_top_of_mem hf]
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : S.arrows f
⊢ Sieve.pullback f R = ⊤
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : S.arrows f
⊢ Sieve.pullback f S ≤ Sieve.pullback f R

tactic: apply Sieve.pullback_monotone _ Hss
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
Hss : S ≤ R
sjx : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : S.arrows f
⊢ Sieve.pullback f S ≤ Sieve.pullback f R
state_after: no goals
Theorem: summable_of_absolute_convergence_real
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: refine .of_norm ⟨r, (hasSum_iff_tendsto_nat_of_nonneg ?_ _).2 ?_⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) atTop (𝓝 r)
⊢ Summable f
state_after: case refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) atTop (𝓝 r)
⊢ ∀ (i : ℕ), 0 ≤ ‖f i‖

case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) atTop (𝓝 r)
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, ‖f i‖) atTop (𝓝 r)

tactic: exact fun i ↦ norm_nonneg _
state_before: case refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) atTop (𝓝 r)
⊢ ∀ (i : ℕ), 0 ≤ ‖f i‖
state_after: no goals

tactic: simpa only using hr
state_before: case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
f : ℕ → ℝ
r : ℝ
hr : Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) atTop (𝓝 r)
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, ‖f i‖) atTop (𝓝 r)
state_after: no goals
Theorem: max_div_min_eq_mabs
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [mabs_div_comm, max_div_min_eq_mabs']
state_before: α : Type u_1
inst✝³ : Group α
inst✝² : LinearOrder α
a✝¹ b✝¹ : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ max a b / min a b = mabs (b / a)
state_after: no goals
Theorem: Matrix.updateRow_transpose
File: Mathlib/Data/Matrix/RowCol.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
⊢ Mᵀ.updateRow j c = (M.updateColumn j c)ᵀ
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
i✝ : n
j✝ : m
⊢ Mᵀ.updateRow j c i✝ j✝ = (M.updateColumn j c)ᵀ i✝ j✝

tactic: rw [transpose_apply, updateRow_apply, updateColumn_apply]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
i✝ : n
j✝ : m
⊢ Mᵀ.updateRow j c i✝ j✝ = (M.updateColumn j c)ᵀ i✝ j✝
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
i✝ : n
j✝ : m
⊢ (if i✝ = j then c j✝ else Mᵀ i✝ j✝) = if i✝ = j then c j✝ else M j✝ i✝

tactic: rfl
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
i✝ : n
j✝ : m
⊢ (if i✝ = j then c j✝ else Mᵀ i✝ j✝) = if i✝ = j then c j✝ else M j✝ i✝
state_after: no goals
Theorem: CategoryTheory.NatTrans.app_sum
File: Mathlib/CategoryTheory/Preadditive/FunctorCategory.lean

tactic: simp only [← appHom_apply, map_sum]
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{u_4, u_2} D
inst✝ : Preadditive D
F G : C ⥤ D
ι : Type u_3
s : Finset ι
X : C
α : ι → (F ⟶ G)
⊢ (∑ i ∈ s, α i).app X = ∑ i ∈ s, (α i).app X
state_after: no goals
Theorem: Nat.Prime.factorization_self
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [hp]
state_before: a b m n p✝ p : ℕ
hp : Prime p
⊢ p.factorization p = 1
state_after: no goals
Theorem: MeasureTheory.compl_cylinder
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

tactic: ext1 f
state_before: ι : Type u_1
α : ι → Type u_2
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
⊢ (cylinder s S)ᶜ = cylinder s Sᶜ
state_after: case h
ι : Type u_1
α : ι → Type u_2
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
f : (i : ι) → α i
⊢ f ∈ (cylinder s S)ᶜ ↔ f ∈ cylinder s Sᶜ

tactic: simp only [mem_compl_iff, mem_cylinder]
state_before: case h
ι : Type u_1
α : ι → Type u_2
s : Finset ι
S : Set ((i : { x // x ∈ s }) → α ↑i)
f : (i : ι) → α i
⊢ f ∈ (cylinder s S)ᶜ ↔ f ∈ cylinder s Sᶜ
state_after: no goals
Theorem: zpow_mono_right
File: Mathlib/Algebra/Order/Group/Basic.lean

tactic: simp [← zpow_add, m.add_comm]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedCommGroup α
m✝ n✝ : ℤ
a b : α
ha : 1 ≤ a
m n : ℤ
h : m ≤ n
⊢ a ^ m * a ^ (n - m) = a ^ n
state_after: no goals
Theorem: FirstOrder.Language.Theory.SemanticallyEquivalent.not
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp_rw [SemanticallyEquivalent, ModelsBoundedFormula, BoundedFormula.realize_iff,
  BoundedFormula.realize_not]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
h : T.SemanticallyEquivalent φ ψ
⊢ T.SemanticallyEquivalent (∼φ) ∼ψ
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
h : T.SemanticallyEquivalent φ ψ
⊢ ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M), ¬φ.Realize v xs ↔ ¬ψ.Realize v xs

tactic: exact fun M v xs => not_congr h.realize_bd_iff
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α n
h : T.SemanticallyEquivalent φ ψ
⊢ ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M), ¬φ.Realize v xs ↔ ¬ψ.Realize v xs
state_after: no goals