1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.mk_pos
File: Mathlib/Data/Real/Basic.lean

tactic: rw [← mk_zero, mk_lt]
state_before: x y : ℝ
f : CauSeq ℚ abs
⊢ 0 < mk f ↔ f.Pos
state_after: x y : ℝ
f : CauSeq ℚ abs
⊢ 0 < f ↔ f.Pos

tactic: exact iff_of_eq (congr_arg Pos (sub_zero f))
state_before: x y : ℝ
f : CauSeq ℚ abs
⊢ 0 < f ↔ f.Pos
state_after: no goals
Theorem: Bornology.isBounded_iff_forall_mem
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rcases s.eq_empty_or_nonempty with rfl | ⟨x, hx⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
x✝ : Bornology α
s t : Set α
x : α
h : ∀ x ∈ s, IsBounded s
⊢ IsBounded s
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
x✝ : Bornology α
t : Set α
x : α
h : ∀ x ∈ ∅, IsBounded ∅
⊢ IsBounded ∅

case inr.intro
ι : Type u_1
α : Type u_2
β : Type u_3
x✝¹ : Bornology α
s t : Set α
x✝ : α
h : ∀ x ∈ s, IsBounded s
x : α
hx : x ∈ s
⊢ IsBounded s

tactic: exacts [isBounded_empty, h x hx]
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
x✝ : Bornology α
t : Set α
x : α
h : ∀ x ∈ ∅, IsBounded ∅
⊢ IsBounded ∅

case inr.intro
ι : Type u_1
α : Type u_2
β : Type u_3
x✝¹ : Bornology α
s t : Set α
x✝ : α
h : ∀ x ∈ s, IsBounded s
x : α
hx : x ∈ s
⊢ IsBounded s
state_after: no goals
Theorem: Real.arccos_of_le_neg_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [arccos, arcsin_of_le_neg_one hx, sub_neg_eq_add, add_halves']
state_before: x✝ y x : ℝ
hx : x ≤ -1
⊢ arccos x = π
state_after: no goals
Theorem: Option.getD_default_eq_iget
File: Mathlib/Data/Option/Basic.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : Inhabited α
o : Option α
⊢ o.getD default = o.iget
state_after: no goals
Theorem: Complex.arg_inv
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [← arg_conj, inv_def, mul_comm]
state_before: a x✝ z x : ℂ
⊢ x⁻¹.arg = if x.arg = π then π else -x.arg
state_after: a x✝ z x : ℂ
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg

tactic: by_cases hx : x = 0
state_before: a x✝ z x : ℂ
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg
state_after: case pos
a x✝ z x : ℂ
hx : x = 0
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg

case neg
a x✝ z x : ℂ
hx : ¬x = 0
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg

tactic: simp [hx]
state_before: case pos
a x✝ z x : ℂ
hx : x = 0
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg
state_after: no goals

tactic: exact arg_real_mul (conj x) (by simp [hx])
state_before: case neg
a x✝ z x : ℂ
hx : ¬x = 0
⊢ (↑(normSq x)⁻¹ * (starRingEnd ℂ) x).arg = ((starRingEnd ℂ) x).arg
state_after: no goals

tactic: simp [hx]
state_before: a x✝ z x : ℂ
hx : ¬x = 0
⊢ 0 < (normSq x)⁻¹
state_after: no goals
Theorem: CategoryTheory.PresheafOfGroups.OneCocycle.ev_symm
File: Mathlib/CategoryTheory/Sites/NonabelianCohomology/H1.lean

tactic: rw [← mul_left_inj (γ.ev j i b a), γ.ev_trans i j i a b a,
  ev_refl, mul_left_inv]
state_before: C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
γ : OneCocycle G U
i j : I
T : C
a : T ⟶ U i
b : T ⟶ U j
⊢ γ.ev i j a b = (γ.ev j i b a)⁻¹
state_after: no goals
Theorem: RelIso.toEquiv_injective
File: Mathlib/Order/RelIso/Basic.lean

tactic: congr
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
e₁ : α ≃ β
o₁ : ∀ {a b : α}, s (e₁ a) (e₁ b) ↔ r a b
e₂ : α ≃ β
map_rel_iff'✝ : ∀ {a b : α}, s (e₂ a) (e₂ b) ↔ r a b
h : { toEquiv := e₁, map_rel_iff' := o₁ }.toEquiv = { toEquiv := e₂, map_rel_iff' := map_rel_iff'✝ }.toEquiv
⊢ { toEquiv := e₁, map_rel_iff' := o₁ } = { toEquiv := e₂, map_rel_iff' := map_rel_iff'✝ }
state_after: no goals
Theorem: Nat.totient_super_multiplicative
File: Mathlib/Data/Nat/Totient.lean

tactic: let d := a.gcd b
state_before: a b : ℕ
⊢ φ a * φ b ≤ φ (a * b)
state_after: a b : ℕ
d : ℕ := a.gcd b
⊢ φ a * φ b ≤ φ (a * b)

tactic: rcases (zero_le a).eq_or_lt with (rfl | ha0)
state_before: a b : ℕ
d : ℕ := a.gcd b
⊢ φ a * φ b ≤ φ (a * b)
state_after: case inl
b : ℕ
d : ℕ := gcd 0 b
⊢ φ 0 * φ b ≤ φ (0 * b)

case inr
a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
⊢ φ a * φ b ≤ φ (a * b)

tactic: have hd0 : 0 < d := Nat.gcd_pos_of_pos_left _ ha0
state_before: case inr
a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
⊢ φ a * φ b ≤ φ (a * b)
state_after: case inr
a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ a * φ b ≤ φ (a * b)

tactic: apply le_of_mul_le_mul_right _ hd0
state_before: case inr
a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ a * φ b ≤ φ (a * b)
state_after: a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ a * φ b * d ≤ φ (a * b) * d

tactic: rw [← totient_gcd_mul_totient_mul a b, mul_comm]
state_before: a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ a * φ b * d ≤ φ (a * b) * d
state_after: a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ (a * b) * φ (a.gcd b) ≤ φ (a * b) * d

tactic: apply mul_le_mul_left' (Nat.totient_le d)
state_before: a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ (a * b) * φ (a.gcd b) ≤ φ (a * b) * d
state_after: no goals

tactic: simp
state_before: case inl
b : ℕ
d : ℕ := gcd 0 b
⊢ φ 0 * φ b ≤ φ (0 * b)
state_after: no goals
Theorem: Multiset.gcd_ndunion
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: rw [← gcd_dedup, dedup_ext.2, gcd_dedup, gcd_add]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ (s₁.ndunion s₂).gcd = GCDMonoid.gcd s₁.gcd s₂.gcd
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁.ndunion s₂ ↔ a ∈ s₁ + s₂

tactic: simp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁.ndunion s₂ ↔ a ∈ s₁ + s₂
state_after: no goals
Theorem: CategoryTheory.Limits.coprod.desc_comp_assoc
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C✝ : Type u
inst✝² : Category.{v, u} C✝
X✝ Y✝ : C✝
C : Type u
inst✝¹ : Category.{u_1, u} C
V W X Y : C
inst✝ : HasBinaryCoproduct X Y
f : V ⟶ W
g : X ⟶ V
h : Y ⟶ V
Z : C
l : W ⟶ Z
⊢ desc g h ≫ f ≫ l = desc (g ≫ f) (h ≫ f) ≫ l
state_after: no goals
Theorem: tprod_one
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [tprod_eq_finprod] <;> simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a a₁ a₂ : α
⊢ ∏' (x : β), 1 = 1
state_after: no goals
Theorem: MeasurableEmbedding.map_comap
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: ext1 t ht
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
⊢ Measure.map f (Measure.comap f μ) = μ.restrict (range f)
state_after: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
t : Set β
ht : MeasurableSet t
⊢ (Measure.map f (Measure.comap f μ)) t = (μ.restrict (range f)) t

tactic: rw [hf.map_apply, comap_apply f hf.injective hf.measurableSet_image' _ (hf.measurable ht),
  image_preimage_eq_inter_range, Measure.restrict_apply ht]
state_before: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure β
t : Set β
ht : MeasurableSet t
⊢ (Measure.map f (Measure.comap f μ)) t = (μ.restrict (range f)) t
state_after: no goals
Theorem: Complex.hasDerivAt_Gamma_one_half
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

tactic: have := HasDerivAt.complex_of_real
  (differentiableAt_Gamma _ ?_) Real.hasDerivAt_Gamma_one_half Gamma_ofReal
state_before: ⊢ HasDerivAt Gamma (-↑√π * (↑γ + 2 * log 2)) (1 / 2)
state_after: case refine_2
this : HasDerivAt Gamma ↑(-√π * (γ + 2 * Real.log 2)) ↑(1 / 2)
⊢ HasDerivAt Gamma (-↑√π * (↑γ + 2 * log 2)) (1 / 2)

case refine_1

⊢ ∀ (m : ℕ), ↑(1 / 2) ≠ -↑m

tactic: simpa only [neg_mul, one_div, ofReal_neg, ofReal_mul, ofReal_add, ofReal_ofNat, ofNat_log,
  ofReal_inv] using this
state_before: case refine_2
this : HasDerivAt Gamma ↑(-√π * (γ + 2 * Real.log 2)) ↑(1 / 2)
⊢ HasDerivAt Gamma (-↑√π * (↑γ + 2 * log 2)) (1 / 2)
state_after: no goals

tactic: intro m
state_before: case refine_1

⊢ ∀ (m : ℕ), ↑(1 / 2) ≠ -↑m
state_after: case refine_1
m : ℕ
⊢ ↑(1 / 2) ≠ -↑m

tactic: rw [← ofReal_natCast, ← ofReal_neg, ne_eq, ofReal_inj]
state_before: case refine_1
m : ℕ
⊢ ↑(1 / 2) ≠ -↑m
state_after: case refine_1
m : ℕ
⊢ ¬1 / 2 = -↑m

tactic: exact ((neg_nonpos.mpr m.cast_nonneg).trans_lt one_half_pos).ne'
state_before: case refine_1
m : ℕ
⊢ ¬1 / 2 = -↑m
state_after: no goals
Theorem: CategoryTheory.preserves_epi_of_preservesColimit
File: Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean

tactic: have := isColimitPushoutCoconeMapOfIsColimit F _ (PushoutCocone.isColimitMkIdId f)
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesColimit (span f f) F
inst✝ : Epi f
⊢ Epi (F.map f)
state_after: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesColimit (span f f) F
inst✝ : Epi f
this : IsColimit (PushoutCocone.mk (F.map (𝟙 Y)) (F.map (𝟙 Y)) ⋯)
⊢ Epi (F.map f)

tactic: simp_rw [F.map_id] at this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesColimit (span f f) F
inst✝ : Epi f
this : IsColimit (PushoutCocone.mk (F.map (𝟙 Y)) (F.map (𝟙 Y)) ⋯)
⊢ Epi (F.map f)
state_after: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesColimit (span f f) F
inst✝ : Epi f
this : IsColimit (PushoutCocone.mk (𝟙 (F.obj Y)) (𝟙 (F.obj Y)) ⋯)
⊢ Epi (F.map f)

tactic: apply PushoutCocone.epi_of_isColimitMkIdId _ this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesColimit (span f f) F
inst✝ : Epi f
this : IsColimit (PushoutCocone.mk (𝟙 (F.obj Y)) (𝟙 (F.obj Y)) ⋯)
⊢ Epi (F.map f)
state_after: no goals
Theorem: Nat.lt_of_lt_pred
File: Mathlib/Data/Nat/Defs.lean

tactic: omega
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : m < n - 1
⊢ m < n
state_after: no goals
Theorem: exists_deriv_eq_zero'
File: Mathlib/Analysis/Calculus/LocalExtr/Rolle.lean

tactic: by_cases h : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
state_before: f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
⊢ ∃ c ∈ Ioo a b, deriv f c = 0
state_after: case pos
f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
⊢ ∃ c ∈ Ioo a b, deriv f c = 0

case neg
f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ¬∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
⊢ ∃ c ∈ Ioo a b, deriv f c = 0

tactic: exact exists_hasDerivAt_eq_zero' hab hfa hfb fun x hx => (h x hx).hasDerivAt
state_before: case pos
f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
⊢ ∃ c ∈ Ioo a b, deriv f c = 0
state_after: no goals

tactic: obtain ⟨c, hc, hcdiff⟩ : ∃ x ∈ Ioo a b, ¬DifferentiableAt ℝ f x := by
  push_neg at h; exact h
state_before: case neg
f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ¬∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
⊢ ∃ c ∈ Ioo a b, deriv f c = 0
state_after: case neg.intro.intro
f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ¬∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
c : ℝ
hc : c ∈ Ioo a b
hcdiff : ¬DifferentiableAt ℝ f c
⊢ ∃ c ∈ Ioo a b, deriv f c = 0

tactic: exact ⟨c, hc, deriv_zero_of_not_differentiableAt hcdiff⟩
state_before: case neg.intro.intro
f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ¬∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
c : ℝ
hc : c ∈ Ioo a b
hcdiff : ¬DifferentiableAt ℝ f c
⊢ ∃ c ∈ Ioo a b, deriv f c = 0
state_after: no goals

tactic: push_neg at h
state_before: f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ¬∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
⊢ ∃ x ∈ Ioo a b, ¬DifferentiableAt ℝ f x
state_after: f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ∃ x ∈ Ioo a b, ¬DifferentiableAt ℝ f x
⊢ ∃ x ∈ Ioo a b, ¬DifferentiableAt ℝ f x

tactic: exact h
state_before: f f' : ℝ → ℝ
a b l : ℝ
hab : a < b
hfa : Tendsto f (𝓝[>] a) (𝓝 l)
hfb : Tendsto f (𝓝[<] b) (𝓝 l)
h : ∃ x ∈ Ioo a b, ¬DifferentiableAt ℝ f x
⊢ ∃ x ∈ Ioo a b, ¬DifferentiableAt ℝ f x
state_after: no goals
Theorem: LieAlgebra.mem_zeroRootSubalgebra
File: Mathlib/Algebra/Lie/Weights/Cartan.lean

tactic: change x ∈ rootSpace H 0 ↔ _
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ x ∈ zeroRootSubalgebra R L H ↔ ∀ (y : ↥H), ∃ k, ((toEnd R (↥H) L) y ^ k) x = 0
state_after: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ x ∈ rootSpace H 0 ↔ ∀ (y : ↥H), ∃ k, ((toEnd R (↥H) L) y ^ k) x = 0

tactic: simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero]
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ x ∈ rootSpace H 0 ↔ ∀ (y : ↥H), ∃ k, ((toEnd R (↥H) L) y ^ k) x = 0
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.Subpresheaf.family_of_elements_compatible
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: intro Y₁ Y₂ Z g₁ g₂ f₁ f₂ h₁ h₂ e
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
⊢ (G.familyOfElementsOfSection s).Compatible
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ U.unop
f₂ : Y₂ ⟶ U.unop
h₁ : (G.sieveOfSection s).arrows f₁
h₂ : (G.sieveOfSection s).arrows f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ G.toPresheaf.map g₁.op (G.familyOfElementsOfSection s f₁ h₁) =
    G.toPresheaf.map g₂.op (G.familyOfElementsOfSection s f₂ h₂)

tactic: refine Subtype.ext ?_
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ U.unop
f₂ : Y₂ ⟶ U.unop
h₁ : (G.sieveOfSection s).arrows f₁
h₂ : (G.sieveOfSection s).arrows f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ G.toPresheaf.map g₁.op (G.familyOfElementsOfSection s f₁ h₁) =
    G.toPresheaf.map g₂.op (G.familyOfElementsOfSection s f₂ h₂)
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ U.unop
f₂ : Y₂ ⟶ U.unop
h₁ : (G.sieveOfSection s).arrows f₁
h₂ : (G.sieveOfSection s).arrows f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ ↑(G.toPresheaf.map g₁.op (G.familyOfElementsOfSection s f₁ h₁)) =
    ↑(G.toPresheaf.map g₂.op (G.familyOfElementsOfSection s f₂ h₂))

tactic: change F.map g₁.op (F.map f₁.op s) = F.map g₂.op (F.map f₂.op s)
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ U.unop
f₂ : Y₂ ⟶ U.unop
h₁ : (G.sieveOfSection s).arrows f₁
h₂ : (G.sieveOfSection s).arrows f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ ↑(G.toPresheaf.map g₁.op (G.familyOfElementsOfSection s f₁ h₁)) =
    ↑(G.toPresheaf.map g₂.op (G.familyOfElementsOfSection s f₂ h₂))
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ U.unop
f₂ : Y₂ ⟶ U.unop
h₁ : (G.sieveOfSection s).arrows f₁
h₂ : (G.sieveOfSection s).arrows f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ F.map g₁.op (F.map f₁.op s) = F.map g₂.op (F.map f₂.op s)

tactic: rw [← FunctorToTypes.map_comp_apply, ← FunctorToTypes.map_comp_apply, ← op_comp, ← op_comp, e]
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
U : Cᵒᵖ
s : F.obj U
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ U.unop
f₂ : Y₂ ⟶ U.unop
h₁ : (G.sieveOfSection s).arrows f₁
h₂ : (G.sieveOfSection s).arrows f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ F.map g₁.op (F.map f₁.op s) = F.map g₂.op (F.map f₂.op s)
state_after: no goals
Theorem: Filter.map_prod_eq_map₂
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂, copy_eq, uncurry_def]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
f : Filter α
g : Filter β
⊢ map (fun p => m p.1 p.2) (f ×ˢ g) = map₂ m f g
state_after: no goals
Theorem: Polynomial.cyclotomic_mul_prime_pow_eq
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Expand.lean

tactic: rw [pow_one, Nat.sub_self, pow_zero, mul_comm, cyclotomic_mul_prime_eq_pow_of_not_dvd R hm]
state_before: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
x✝ : 0 < 1
⊢ cyclotomic (p ^ 1 * m) R = cyclotomic m R ^ (p ^ 1 - p ^ (1 - 1))
state_after: no goals

tactic: have hdiv : p ∣ p ^ a.succ * m := ⟨p ^ a * m, by rw [← mul_assoc, pow_succ']⟩
state_before: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
⊢ cyclotomic (p ^ (a + 2) * m) R = cyclotomic m R ^ (p ^ (a + 2) - p ^ (a + 2 - 1))
state_after: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
hdiv : p ∣ p ^ a.succ * m
⊢ cyclotomic (p ^ (a + 2) * m) R = cyclotomic m R ^ (p ^ (a + 2) - p ^ (a + 2 - 1))

tactic: rw [pow_succ', mul_assoc, mul_comm, cyclotomic_mul_prime_dvd_eq_pow R hdiv,
  cyclotomic_mul_prime_pow_eq _ _ a.succ_pos, ← pow_mul]
state_before: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
hdiv : p ∣ p ^ a.succ * m
⊢ cyclotomic (p ^ (a + 2) * m) R = cyclotomic m R ^ (p ^ (a + 2) - p ^ (a + 2 - 1))
state_after: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
hdiv : p ∣ p ^ a.succ * m
⊢ cyclotomic m R ^ ((p ^ a.succ - p ^ (a.succ - 1)) * p) = cyclotomic m R ^ (p * p ^ (a + 1) - p ^ (a + 2 - 1))

R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
hdiv : p ∣ p ^ a.succ * m
⊢ ¬p ∣ m

tactic: rw [← mul_assoc, pow_succ']
state_before: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
⊢ p ^ a.succ * m = p * (p ^ a * m)
state_after: no goals

tactic: simp only [tsub_zero, Nat.succ_sub_succ_eq_sub]
state_before: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
hdiv : p ∣ p ^ a.succ * m
⊢ cyclotomic m R ^ ((p ^ a.succ - p ^ (a.succ - 1)) * p) = cyclotomic m R ^ (p * p ^ (a + 1) - p ^ (a + 2 - 1))
state_after: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
hdiv : p ∣ p ^ a.succ * m
⊢ cyclotomic m R ^ ((p ^ a.succ - p ^ a) * p) = cyclotomic m R ^ (p * p ^ (a + 1) - p ^ (a + 1))

tactic: rw [Nat.mul_sub_right_distrib, mul_comm, pow_succ]
state_before: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
hdiv : p ∣ p ^ a.succ * m
⊢ cyclotomic m R ^ ((p ^ a.succ - p ^ a) * p) = cyclotomic m R ^ (p * p ^ (a + 1) - p ^ (a + 1))
state_after: no goals

tactic: assumption
state_before: R : Type u_1
p m : ℕ
inst✝² : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hm : ¬p ∣ m
a : ℕ
x✝ : 0 < a + 2
hdiv : p ∣ p ^ a.succ * m
⊢ ¬p ∣ m
state_after: no goals
Theorem: Nat.exists_mul_self'
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa only [Nat.pow_two] using exists_mul_self x
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
x : ℕ
⊢ (∃ n, n ^ 2 = x) ↔ x.sqrt ^ 2 = x
state_after: no goals
Theorem: CategoryTheory.op_inv
File: Mathlib/CategoryTheory/Opposites.lean

tactic: apply IsIso.eq_inv_of_hom_inv_id
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ (inv f).op = inv f.op
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ f.op ≫ (inv f).op = 𝟙 { unop := Y }

tactic: rw [← op_comp, IsIso.inv_hom_id, op_id]
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ f.op ≫ (inv f).op = 𝟙 { unop := Y }
state_after: no goals
Theorem: WithLp.prod_dist_eq_of_L2
File: Mathlib/Analysis/NormedSpace/ProdLp.lean

tactic: simp_rw [dist_eq_norm, prod_norm_eq_of_L2]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
x y : WithLp 2 (α × β)
⊢ dist x y = √(dist x.1 y.1 ^ 2 + dist x.2 y.2 ^ 2)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
x y : WithLp 2 (α × β)
⊢ √(‖(x - y).1‖ ^ 2 + ‖(x - y).2‖ ^ 2) = √(‖x.1 - y.1‖ ^ 2 + ‖x.2 - y.2‖ ^ 2)

tactic: rfl
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
x y : WithLp 2 (α × β)
⊢ √(‖(x - y).1‖ ^ 2 + ‖(x - y).2‖ ^ 2) = √(‖x.1 - y.1‖ ^ 2 + ‖x.2 - y.2‖ ^ 2)
state_after: no goals
Theorem: exists_ne_mem_inter_of_not_pairwise_disjoint
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: rw [← pairwise_univ] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f : ι → Set α
h : ¬Pairwise (Disjoint on f)
⊢ ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f : ι → Set α
h : ¬univ.Pairwise (Disjoint on f)
⊢ ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j

tactic: obtain ⟨i, _hi, j, _hj, h⟩ := exists_ne_mem_inter_of_not_pairwiseDisjoint h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f : ι → Set α
h : ¬univ.Pairwise (Disjoint on f)
⊢ ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f : ι → Set α
h✝ : ¬univ.Pairwise (Disjoint on f)
i : ι
_hi : i ∈ univ
j : ι
_hj : j ∈ univ
h : i ≠ j ∧ ∃ x, x ∈ f i ∩ f j
⊢ ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j

tactic: exact ⟨i, j, h⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f : ι → Set α
h✝ : ¬univ.Pairwise (Disjoint on f)
i : ι
_hi : i ∈ univ
j : ι
_hj : j ∈ univ
h : i ≠ j ∧ ∃ x, x ∈ f i ∩ f j
⊢ ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j
state_after: no goals