1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsUpperSet.total
File: Mathlib/Order/UpperLower/Basic.lean

tactic: by_contra! h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
⊢ s ⊆ t ∨ t ⊆ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
h : ¬s ⊆ t ∧ ¬t ⊆ s
⊢ False

tactic: simp_rw [Set.not_subset] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
h : ¬s ⊆ t ∧ ¬t ⊆ s
⊢ False
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
h : (∃ a ∈ s, a ∉ t) ∧ ∃ a ∈ t, a ∉ s
⊢ False

tactic: obtain ⟨⟨a, has, hat⟩, b, hbt, hbs⟩ := h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
h : (∃ a ∈ s, a ∉ t) ∧ ∃ a ∈ t, a ∉ s
⊢ False
state_after: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
a : α
has : a ∈ s
hat : a ∉ t
b : α
hbt : b ∈ t
hbs : b ∉ s
⊢ False

tactic: obtain hab | hba := le_total a b
state_before: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
a : α
has : a ∈ s
hat : a ∉ t
b : α
hbt : b ∈ t
hbs : b ∉ s
⊢ False
state_after: case intro.intro.intro.intro.intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
a : α
has : a ∈ s
hat : a ∉ t
b : α
hbt : b ∈ t
hbs : b ∉ s
hab : a ≤ b
⊢ False

case intro.intro.intro.intro.intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
a : α
has : a ∈ s
hat : a ∉ t
b : α
hbt : b ∈ t
hbs : b ∉ s
hba : b ≤ a
⊢ False

tactic: exact hbs (hs hab has)
state_before: case intro.intro.intro.intro.intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
a : α
has : a ∈ s
hat : a ∉ t
b : α
hbt : b ∈ t
hbs : b ∉ s
hab : a ≤ b
⊢ False
state_after: no goals

tactic: exact hat (ht hba hbt)
state_before: case intro.intro.intro.intro.intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LinearOrder α
s t : Set α
hs : IsUpperSet s
ht : IsUpperSet t
a : α
has : a ∈ s
hat : a ∉ t
b : α
hbt : b ∈ t
hbs : b ∉ s
hba : b ≤ a
⊢ False
state_after: no goals
Theorem: Valuation.Integers.dvd_of_le
File: Mathlib/RingTheory/Valuation/Integers.lean

tactic: rw [← v.map_one, ← inv_mul_cancel hy, v.map_mul, v.map_mul]
state_before: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x y : O
h : v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)
hy : (algebraMap O F) y ≠ 0
⊢ v (((algebraMap O F) y)⁻¹ * (algebraMap O F) x) ≤ 1
state_after: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x y : O
h : v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)
hy : (algebraMap O F) y ≠ 0
⊢ v ((algebraMap O F) y)⁻¹ * v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)⁻¹ * v ((algebraMap O F) y)

tactic: exact mul_le_mul_left' h _
state_before: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x y : O
h : v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)
hy : (algebraMap O F) y ≠ 0
⊢ v ((algebraMap O F) y)⁻¹ * v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)⁻¹ * v ((algebraMap O F) y)
state_after: no goals
Theorem: IsGroupHom.one_ker_inv'
File: Mathlib/Deprecated/Subgroup.lean

tactic: rw [hf.map_mul, hf.map_inv] at h
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f (a⁻¹ * b) = 1
⊢ f a = f b
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : (f a)⁻¹ * f b = 1
⊢ f a = f b

tactic: apply inv_injective
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : (f a)⁻¹ * f b = 1
⊢ f a = f b
state_after: case a
G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : (f a)⁻¹ * f b = 1
⊢ (f a)⁻¹ = (f b)⁻¹

tactic: rw [eq_inv_of_mul_eq_one_left h]
state_before: case a
G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : (f a)⁻¹ * f b = 1
⊢ (f a)⁻¹ = (f b)⁻¹
state_after: no goals
Theorem: Set.Finite.exists_not_mem
File: Mathlib/Data/Set/Finite.lean

tactic: by_contra! h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
inst✝ : Infinite α
hs : s.Finite
⊢ ∃ a, a ∉ s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
inst✝ : Infinite α
hs : s.Finite
h : ∀ (a : α), a ∈ s
⊢ False

tactic: exact infinite_univ (hs.subset fun a _ ↦ h _)
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
inst✝ : Infinite α
hs : s.Finite
h : ∀ (a : α), a ∈ s
⊢ False
state_after: no goals
Theorem: MeasureTheory.setLIntegral_congr_fun
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral_congr_ae]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
hfg : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = g x
⊢ ∫⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, g x ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
hfg : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = g x
⊢ f =ᶠ[ae (μ.restrict s)] g

tactic: rw [EventuallyEq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
hfg : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = g x
⊢ f =ᶠ[ae (μ.restrict s)] g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
hfg : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = g x
⊢ ∀ᵐ (x : α) ∂μ.restrict s, f x = g x

tactic: rwa [ae_restrict_iff' hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
hfg : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = g x
⊢ ∀ᵐ (x : α) ∂μ.restrict s, f x = g x
state_after: no goals
Theorem: AlgebraicGeometry.universallyClosed_isLocalAtTarget
File: Mathlib/AlgebraicGeometry/Morphisms/UniversallyClosed.lean

tactic: rw [universallyClosed_eq]
state_before: X Y : Scheme
f : X ⟶ Y
⊢ PropertyIsLocalAtTarget @UniversallyClosed
state_after: X Y : Scheme
f : X ⟶ Y
⊢ PropertyIsLocalAtTarget (topologically @IsClosedMap).universally

tactic: apply universally_isLocalAtTarget_of_morphismRestrict
state_before: X Y : Scheme
f : X ⟶ Y
⊢ PropertyIsLocalAtTarget (topologically @IsClosedMap).universally
state_after: case hP₁
X Y : Scheme
f : X ⟶ Y
⊢ (topologically @IsClosedMap).RespectsIso

case hP₂
X Y : Scheme
f : X ⟶ Y
⊢ ∀ {X Y : Scheme} (f : X ⟶ Y) {ι : Type u_1} (U : ι → Opens ↑↑Y.toPresheafedSpace),
    iSup U = ⊤ → (∀ (i : ι), topologically (@IsClosedMap) (f ∣_ U i)) → topologically (@IsClosedMap) f

tactic: exact topologically_isClosedMap_respectsIso
state_before: case hP₁
X Y : Scheme
f : X ⟶ Y
⊢ (topologically @IsClosedMap).RespectsIso
state_after: no goals

tactic: intro X Y f ι U hU H
state_before: case hP₂
X Y : Scheme
f : X ⟶ Y
⊢ ∀ {X Y : Scheme} (f : X ⟶ Y) {ι : Type u_1} (U : ι → Opens ↑↑Y.toPresheafedSpace),
    iSup U = ⊤ → (∀ (i : ι), topologically (@IsClosedMap) (f ∣_ U i)) → topologically (@IsClosedMap) f
state_after: case hP₂
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
ι : Type u_1
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
H : ∀ (i : ι), topologically (@IsClosedMap) (f ∣_ U i)
⊢ topologically (@IsClosedMap) f

tactic: simp_rw [topologically, morphismRestrict_val_base] at H
state_before: case hP₂
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
ι : Type u_1
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
H : ∀ (i : ι), topologically (@IsClosedMap) (f ∣_ U i)
⊢ topologically (@IsClosedMap) f
state_after: case hP₂
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
ι : Type u_1
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
H : ∀ (i : ι), IsClosedMap ((U i).carrier.restrictPreimage ⇑f.val.base)
⊢ topologically (@IsClosedMap) f

tactic: exact (isClosedMap_iff_isClosedMap_of_iSup_eq_top hU).mpr H
state_before: case hP₂
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
ι : Type u_1
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
H : ∀ (i : ι), IsClosedMap ((U i).carrier.restrictPreimage ⇑f.val.base)
⊢ topologically (@IsClosedMap) f
state_after: no goals
Theorem: MeasureTheory.tendsto_Lp_of_tendstoInMeasure
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

tactic: refine tendsto_of_subseq_tendsto fun ns hns => ?_
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
inst✝ : IsFiniteMeasure μ
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hg : Memℒp g p μ
hui : UnifIntegrable f p μ
hfg : TendstoInMeasure μ f atTop g
⊢ Tendsto (fun n => snorm (f n - g) p μ) atTop (𝓝 0)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
inst✝ : IsFiniteMeasure μ
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hg : Memℒp g p μ
hui : UnifIntegrable f p μ
hfg : TendstoInMeasure μ f atTop g
ns : ℕ → ℕ
hns : Tendsto ns atTop atTop
⊢ ∃ ms, Tendsto (fun n => snorm (f (ns (ms n)) - g) p μ) atTop (𝓝 0)

tactic: obtain ⟨ms, _, hms'⟩ := TendstoInMeasure.exists_seq_tendsto_ae fun ε hε => (hfg ε hε).comp hns
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
inst✝ : IsFiniteMeasure μ
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hg : Memℒp g p μ
hui : UnifIntegrable f p μ
hfg : TendstoInMeasure μ f atTop g
ns : ℕ → ℕ
hns : Tendsto ns atTop atTop
⊢ ∃ ms, Tendsto (fun n => snorm (f (ns (ms n)) - g) p μ) atTop (𝓝 0)
state_after: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
inst✝ : IsFiniteMeasure μ
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hg : Memℒp g p μ
hui : UnifIntegrable f p μ
hfg : TendstoInMeasure μ f atTop g
ns : ℕ → ℕ
hns : Tendsto ns atTop atTop
ms : ℕ → ℕ
left✝ : StrictMono ms
hms' : ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns (ms i)) x) atTop (𝓝 (g x))
⊢ ∃ ms, Tendsto (fun n => snorm (f (ns (ms n)) - g) p μ) atTop (𝓝 0)

tactic: exact ⟨ms,
  tendsto_Lp_of_tendsto_ae hp hp' (fun _ => hf _) hg (fun ε hε =>
    let ⟨δ, hδ, hδ'⟩ := hui hε
    ⟨δ, hδ, fun i s hs hμs => hδ' _ s hs hμs⟩)
    hms'⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedAddCommGroup β
p : ℝ≥0∞
f : ℕ → α → β
g : α → β
inst✝ : IsFiniteMeasure μ
hp : 1 ≤ p
hp' : p ≠ ⊤
hf : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
hg : Memℒp g p μ
hui : UnifIntegrable f p μ
hfg : TendstoInMeasure μ f atTop g
ns : ℕ → ℕ
hns : Tendsto ns atTop atTop
ms : ℕ → ℕ
left✝ : StrictMono ms
hms' : ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns (ms i)) x) atTop (𝓝 (g x))
⊢ ∃ ms, Tendsto (fun n => snorm (f (ns (ms n)) - g) p μ) atTop (𝓝 0)
state_after: no goals
Theorem: eq_of_germ_isConstant
File: Mathlib/Topology/Germ.lean

tactic: trivial
state_before: F : Type u_1
G : Type u_2
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
X : Type u_3
Y : Type u_4
Z : Type u_5
inst✝ : TopologicalSpace X
f g : X → Y
A : Set X
x✝ : X
i : PreconnectedSpace X
h : ∀ (x : X), (↑f).IsConstant
x x' : X
⊢ x ∈ univ
state_after: no goals

tactic: trivial
state_before: F : Type u_1
G : Type u_2
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
X : Type u_3
Y : Type u_4
Z : Type u_5
inst✝ : TopologicalSpace X
f g : X → Y
A : Set X
x✝ : X
i : PreconnectedSpace X
h : ∀ (x : X), (↑f).IsConstant
x x' : X
⊢ x' ∈ univ
state_after: no goals
Theorem: Finset.image_image₂_antidistrib
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [image₂_swap f]
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
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : β' → α' → δ
g₁ : β → β'
g₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)
⊢ image g (image₂ f s t) = image₂ f' (image g₁ t) (image g₂ s)
state_after: α : 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
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : β' → α' → δ
g₁ : β → β'
g₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)
⊢ image g (image₂ (fun a b => f b a) t s) = image₂ f' (image g₁ t) (image g₂ s)

tactic: exact image_image₂_distrib fun _ _ => h_antidistrib _ _
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
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : β' → α' → δ
g₁ : β → β'
g₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)
⊢ image g (image₂ (fun a b => f b a) t s) = image₂ f' (image g₁ t) (image g₂ s)
state_after: no goals
Theorem: FractionalIdeal.absNorm_eq_zero_iff
File: Mathlib/RingTheory/FractionalIdeal/Norm.lean

tactic: refine ⟨fun h ↦ zero_of_num_eq_bot zero_not_mem_nonZeroDivisors ?_, fun h ↦ h ▸ absNorm_bot⟩
state_before: R : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : IsDedekindDomain R
inst✝⁵ : Module.Free ℤ R
inst✝⁴ : Module.Finite ℤ R
K : Type u_2
inst✝³ : CommRing K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : NoZeroDivisors K
I : FractionalIdeal R⁰ K
⊢ absNorm I = 0 ↔ I = 0
state_after: R : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : IsDedekindDomain R
inst✝⁵ : Module.Free ℤ R
inst✝⁴ : Module.Finite ℤ R
K : Type u_2
inst✝³ : CommRing K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : NoZeroDivisors K
I : FractionalIdeal R⁰ K
h : absNorm I = 0
⊢ I.num = ⊥

tactic: rw [absNorm_eq, div_eq_zero_iff] at h
state_before: R : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : IsDedekindDomain R
inst✝⁵ : Module.Free ℤ R
inst✝⁴ : Module.Finite ℤ R
K : Type u_2
inst✝³ : CommRing K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : NoZeroDivisors K
I : FractionalIdeal R⁰ K
h : absNorm I = 0
⊢ I.num = ⊥
state_after: R : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : IsDedekindDomain R
inst✝⁵ : Module.Free ℤ R
inst✝⁴ : Module.Finite ℤ R
K : Type u_2
inst✝³ : CommRing K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : NoZeroDivisors K
I : FractionalIdeal R⁰ K
h : ↑(Ideal.absNorm I.num) = 0 ∨ ↑|(Algebra.norm ℤ) ↑I.den| = 0
⊢ I.num = ⊥

tactic: refine Ideal.absNorm_eq_zero_iff.mp <| Nat.cast_eq_zero.mp <| h.resolve_right ?_
state_before: R : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : IsDedekindDomain R
inst✝⁵ : Module.Free ℤ R
inst✝⁴ : Module.Finite ℤ R
K : Type u_2
inst✝³ : CommRing K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : NoZeroDivisors K
I : FractionalIdeal R⁰ K
h : ↑(Ideal.absNorm I.num) = 0 ∨ ↑|(Algebra.norm ℤ) ↑I.den| = 0
⊢ I.num = ⊥
state_after: R : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : IsDedekindDomain R
inst✝⁵ : Module.Free ℤ R
inst✝⁴ : Module.Finite ℤ R
K : Type u_2
inst✝³ : CommRing K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : NoZeroDivisors K
I : FractionalIdeal R⁰ K
h : ↑(Ideal.absNorm I.num) = 0 ∨ ↑|(Algebra.norm ℤ) ↑I.den| = 0
⊢ ¬↑|(Algebra.norm ℤ) ↑I.den| = 0

tactic: simpa [Algebra.norm_eq_zero_iff] using nonZeroDivisors.coe_ne_zero _
state_before: R : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : IsDedekindDomain R
inst✝⁵ : Module.Free ℤ R
inst✝⁴ : Module.Finite ℤ R
K : Type u_2
inst✝³ : CommRing K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : NoZeroDivisors K
I : FractionalIdeal R⁰ K
h : ↑(Ideal.absNorm I.num) = 0 ∨ ↑|(Algebra.norm ℤ) ↑I.den| = 0
⊢ ¬↑|(Algebra.norm ℤ) ↑I.den| = 0
state_after: no goals
Theorem: IsSMulRegular.of_smul_eq_one
File: Mathlib/Algebra/Regular/SMul.lean

tactic: rw [h]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝⁴ : Monoid S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : MulAction S M
inst✝ : IsScalarTower R S M
h : a • s = 1
⊢ IsSMulRegular M (a • s)
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝⁴ : Monoid S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : MulAction S M
inst✝ : IsScalarTower R S M
h : a • s = 1
⊢ IsSMulRegular M 1

tactic: exact one M
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝⁴ : Monoid S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : MulAction S M
inst✝ : IsScalarTower R S M
h : a • s = 1
⊢ IsSMulRegular M 1
state_after: no goals
Theorem: LowerSet.Iic_iInf₂
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [Iic_iInf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : CompleteLattice α
f : (i : ι) → κ i → α
⊢ Iic (⨅ i, ⨅ j, f i j) = ⨅ i, ⨅ j, Iic (f i j)
state_after: no goals
Theorem: String.extract_of_valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp only [extract]
state_before: l m r : List Char
⊢ { data := l ++ m ++ r }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } = { data := m }
state_after: l m r : List Char
⊢ (if utf8Len l ≥ utf8Len l + utf8Len m then ""
    else { data := extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } }) =
    { data := m }

tactic: split
state_before: l m r : List Char
⊢ (if utf8Len l ≥ utf8Len l + utf8Len m then ""
    else { data := extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } }) =
    { data := m }
state_after: case isTrue
l m r : List Char
h✝ : utf8Len l ≥ utf8Len l + utf8Len m
⊢ "" = { data := m }

case isFalse
l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ { data := extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } } = { data := m }

tactic: next h => rw [utf8Len_eq_zero.1 <| Nat.le_zero.1 <| Nat.add_le_add_iff_left.1 h]
state_before: case isTrue
l m r : List Char
h✝ : utf8Len l ≥ utf8Len l + utf8Len m
⊢ "" = { data := m }
state_after: no goals

tactic: rw [utf8Len_eq_zero.1 <| Nat.le_zero.1 <| Nat.add_le_add_iff_left.1 h]
state_before: l m r : List Char
h : utf8Len l ≥ utf8Len l + utf8Len m
⊢ "" = { data := m }
state_after: no goals

tactic: congr
state_before: case isFalse
l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ { data := extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } } = { data := m }
state_after: case isFalse.e_data
l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } = m

tactic: rw [List.append_assoc, extract.go₁_append_right _ _ _ _ _ (by rfl)]
state_before: case isFalse.e_data
l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } = m
state_after: case isFalse.e_data
l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ extract.go₂ (m ++ r) { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } = m

tactic: apply extract.go₂_append_left
state_before: case isFalse.e_data
l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ extract.go₂ (m ++ r) { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } = m
state_after: case isFalse.e_data.a
l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ utf8Len l + utf8Len m = utf8Len m + utf8Len l

tactic: apply Nat.add_comm
state_before: case isFalse.e_data.a
l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ utf8Len l + utf8Len m = utf8Len m + utf8Len l
state_after: no goals

tactic: rfl
state_before: l m r : List Char
h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m
⊢ utf8Len l = utf8Len l + Pos.byteIdx 0
state_after: no goals
Theorem: ArithmeticFunction.LSeries_zeta_mul_Lseries_moebius
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

tactic: rw [← LSeries_convolution' (LSeriesSummable_zeta_iff.mpr hs)
  (LSeriesSummable_moebius_iff.mpr hs)]
state_before: s : ℂ
hs : 1 < s.re
⊢ L (fun n => ↑(ζ n)) s * L (fun n => ↑(μ n)) s = 1
state_after: s : ℂ
hs : 1 < s.re
⊢ L ((fun x => ↑(ζ x)) ⍟ fun n => ↑(μ n)) s = 1

tactic: simp only [← natCoe_apply, ← intCoe_apply, coe_mul, coe_zeta_mul_coe_moebius, one_eq_delta,
  LSeries_delta, Pi.one_apply]
state_before: s : ℂ
hs : 1 < s.re
⊢ L ((fun x => ↑(ζ x)) ⍟ fun n => ↑(μ n)) s = 1
state_after: no goals
Theorem: Primrec.list_findIdx
File: Mathlib/Computability/Primrec.lean

tactic: dsimp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → List β
p : α → β → Bool
hf : Primrec f
hp : Primrec₂ p
a : α
⊢ List.foldr (fun b s => bif p (a, b, s).1 (a, b, s).2.1 then 0 else (a, b, s).2.2.succ) 0 (f a) =
    List.findIdx (p a) (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → List β
p : α → β → Bool
hf : Primrec f
hp : Primrec₂ p
a : α
⊢ List.foldr (fun b s => bif p a b then 0 else s + 1) 0 (f a) = List.findIdx (p a) (f a)

tactic: induction f a <;> simp [List.findIdx_cons, *]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → List β
p : α → β → Bool
hf : Primrec f
hp : Primrec₂ p
a : α
⊢ List.foldr (fun b s => bif p a b then 0 else s + 1) 0 (f a) = List.findIdx (p a) (f a)
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.tensorRightTensor_inv_app
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp [tensorRightTensor]
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Z : C
⊢ (tensorRightTensor X Y).inv.app Z = (α_ Z X Y).hom
state_after: no goals