tasksource/leandojo huggingface dataset:
Theorem: Set.compl_sUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.144485
γ : Type ?u.144488
ι : Sort ?u.144491
ι' : Sort ?u.144494
ι₂ : Sort ?u.144497
κ : ι → Sort ?u.144502
κ₁ : ι → Sort ?u.144507
κ₂ : ι → Sort ?u.144512
κ' : ι' → Sort ?u.144517
S : Set (Set α)
x : α
⊢ x ∈ (⋃₀ S)ᶜ ↔ x ∈ ⋂₀ (compl '' S)
Theorem: Ideal.map_span
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine (Submodule.span_eq_of_le _ ?_ ?_).symm
state_before: R : Type u
S : Type v
F : Type u_1
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f✝ : F
I J : Ideal R
K L : Ideal S
G : Type ?u.756873
rcg : RingHomClass G S R
f : F
s : Set R
⊢ map f (span s) = span (↑f '' s)

tactic: rintro _ ⟨x, hx, rfl⟩
state_before: case refine_1
R : Type u
S : Type v
F : Type u_1
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f✝ : F
I J : Ideal R
K L : Ideal S
G : Type ?u.756873
rcg : RingHomClass G S R
f : F
s : Set R
⊢ ↑f '' s ⊆ ↑(map f (span s))

tactic: exact mem_map_of_mem f (subset_span hx)
state_before: case refine_1.intro.intro
R : Type u
S : Type v
F : Type u_1
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f✝ : F
I J : Ideal R
K L : Ideal S
G : Type ?u.756873
rcg : RingHomClass G S R
f : F
s : Set R
x : R
hx : x ∈ s
⊢ ↑f x ∈ ↑(map f (span s))

tactic: rw [map_le_iff_le_comap, span_le, coe_comap, ← Set.image_subset_iff]
state_before: case refine_2
R : Type u
S : Type v
F : Type u_1
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f✝ : F
I J : Ideal R
K L : Ideal S
G : Type ?u.756873
rcg : RingHomClass G S R
f : F
s : Set R
⊢ map f (span s) ≤ Submodule.span S (↑f '' s)

tactic: exact subset_span
state_before: case refine_2
R : Type u
S : Type v
F : Type u_1
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f✝ : F
I J : Ideal R
K L : Ideal S
G : Type ?u.756873
rcg : RingHomClass G S R
f : F
s : Set R
⊢ ↑f '' s ⊆ ↑(Submodule.span S (↑f '' s))
Theorem: Real.sqrt_ne_zero'
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← not_le, not_iff_not, sqrt_eq_zero']
state_before: x y : ℝ
⊢ sqrt x ≠ 0 ↔ 0 < x
Theorem: equiv_lpPiLp_norm
File: Mathlib/Analysis/NormedSpace/LpEquiv.lean

tactic: rcases p.trichotomy with (rfl | rfl | h)
state_before: α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
p : ℝ≥0∞
inst✝ : Fintype α
f : { x // x ∈ lp E p }
⊢ ‖↑Equiv.lpPiLp f‖ = ‖f‖

tactic: rw [PiLp.norm_eq_card, lp.norm_eq_card_dsupport]
state_before: case inl
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Fintype α
f : { x // x ∈ lp E 0 }
⊢ ‖↑Equiv.lpPiLp f‖ = ‖f‖

tactic: rw [PiLp.norm_eq_ciSup, lp.norm_eq_ciSup]
state_before: case inr.inl
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Fintype α
f : { x // x ∈ lp E ⊤ }
⊢ ‖↑Equiv.lpPiLp f‖ = ‖f‖

tactic: rfl
state_before: case inr.inl
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Fintype α
f : { x // x ∈ lp E ⊤ }
⊢ (⨆ (i : α), ‖↑Equiv.lpPiLp f i‖) = ⨆ (i : α), ‖↑f i‖

tactic: rw [PiLp.norm_eq_sum h, lp.norm_eq_tsum_rpow h, tsum_fintype]
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
p : ℝ≥0∞
inst✝ : Fintype α
f : { x // x ∈ lp E p }
h : 0 < ENNReal.toReal p
⊢ ‖↑Equiv.lpPiLp f‖ = ‖f‖

tactic: rfl
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
p : ℝ≥0∞
inst✝ : Fintype α
f : { x // x ∈ lp E p }
h : 0 < ENNReal.toReal p
⊢ (Finset.sum Finset.univ fun i => ‖↑Equiv.lpPiLp f i‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p) =
    (Finset.sum Finset.univ fun b => ‖↑f b‖ ^ ENNReal.toReal p) ^ (1 / ENNReal.toReal p)
Theorem: generateFrom_generatePiSystem_eq
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: apply le_antisymm <;> apply generateFrom_le
state_before: α : Type u_1
g : Set (Set α)
⊢ generateFrom (generatePiSystem g) = generateFrom g

tactic: exact fun t h_t => generateFrom_measurableSet_of_generatePiSystem t h_t
state_before: case a.h
α : Type u_1
g : Set (Set α)
⊢ ∀ (t : Set α), t ∈ generatePiSystem g → MeasurableSet t

tactic: exact fun t h_t => measurableSet_generateFrom (generatePiSystem.base h_t)
state_before: case a.h
α : Type u_1
g : Set (Set α)
⊢ ∀ (t : Set α), t ∈ g → MeasurableSet t
Theorem: Int.mul_emod_right
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, mul_emod_left]
state_before: a b : Int
⊢ a * b % a = 0
Theorem: Ideal.Filtration.Stable.exists_pow_smul_eq
File: Mathlib/RingTheory/Filtration.lean

tactic: obtain ⟨n₀, hn⟩ := h
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
⊢ ∃ n₀, ∀ (k : ℕ), N F (n₀ + k) = I ^ k • N F n₀

tactic: use n₀
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
n₀ : ℕ
hn : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
⊢ ∃ n₀, ∀ (k : ℕ), N F (n₀ + k) = I ^ k • N F n₀

tactic: intro k
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
n₀ : ℕ
hn : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
⊢ ∀ (k : ℕ), N F (n₀ + k) = I ^ k • N F n₀

tactic: induction' k with _ ih
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
n₀ : ℕ
hn : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
k : ℕ
⊢ N F (n₀ + k) = I ^ k • N F n₀

tactic: simp
state_before: case intro.zero
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
n₀ : ℕ
hn : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
⊢ N F (n₀ + Nat.zero) = I ^ Nat.zero • N F n₀

tactic: rw [Nat.succ_eq_add_one, ← add_assoc, ← hn, ih, add_comm, pow_add, mul_smul, pow_one]
state_before: case intro.succ
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
n₀ : ℕ
hn : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
n✝ : ℕ
ih : N F (n₀ + n✝) = I ^ n✝ • N F n₀
⊢ N F (n₀ + Nat.succ n✝) = I ^ Nat.succ n✝ • N F n₀

tactic: linarith
state_before: case intro.succ.a
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
n₀ : ℕ
hn : ∀ (n : ℕ), n ≥ n₀ → I • N F n = N F (n + 1)
n✝ : ℕ
ih : N F (n₀ + n✝) = I ^ n✝ • N F n₀
⊢ n₀ + n✝ ≥ n₀
Theorem: Surjective.wellFounded_iff
File: Mathlib/Order/RelIso/Basic.lean

tactic: refine RelHomClass.wellFounded (RelHom.mk ?_ ?_ : s →r r)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.15958
δ : Type ?u.15961
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
⊢ WellFounded r → WellFounded s

tactic: intro a b h
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type ?u.15958
δ : Type ?u.15961
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
⊢ ∀ {a b : β}, s a b → r (Classical.choose (_ : HasRightInverse f) a) (Classical.choose (_ : HasRightInverse f) b)

tactic: apply o.2
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type ?u.15958
δ : Type ?u.15961
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
a b : β
h : s a b
⊢ r (Classical.choose (_ : HasRightInverse f) a) (Classical.choose (_ : HasRightInverse f) b)

tactic: convert h
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type ?u.15958
δ : Type ?u.15961
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
a b : β
h : s a b
⊢ s (f (Classical.choose (_ : HasRightInverse f) a)) (f (Classical.choose (_ : HasRightInverse f) b))

tactic: iterate 2 apply Classical.choose_spec hf.hasRightInverse
state_before: case h.e'_1
α : Type u_1
β : Type u_2
γ : Type ?u.15958
δ : Type ?u.15961
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
a b : β
h : s a b
⊢ f (Classical.choose (_ : HasRightInverse f) a) = a

case h.e'_2
α : Type u_1
β : Type u_2
γ : Type ?u.15958
δ : Type ?u.15961
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
a b : β
h : s a b
⊢ f (Classical.choose (_ : HasRightInverse f) b) = b

tactic: exact Classical.choose hf.hasRightInverse
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type ?u.15958
δ : Type ?u.15961
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
⊢ β → α

tactic: apply Classical.choose_spec hf.hasRightInverse
state_before: case h.e'_2
α : Type u_1
β : Type u_2
γ : Type ?u.15958
δ : Type ?u.15961
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
a b : β
h : s a b
⊢ f (Classical.choose (_ : HasRightInverse f) b) = b
Theorem: totallySeparatedSpace_of_t1_of_basis_clopen
File: Mathlib/Topology/Separation.lean

tactic: constructor
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
h : IsTopologicalBasis {s | IsClopen s}
⊢ TotallySeparatedSpace α

tactic: rintro x - y - hxy
state_before: case isTotallySeparated_univ
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
h : IsTopologicalBasis {s | IsClopen s}
⊢ IsTotallySeparated univ

tactic: rcases h.mem_nhds_iff.mp (isOpen_ne.mem_nhds hxy) with ⟨U, hU, hxU, hyU⟩
state_before: case isTotallySeparated_univ
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
h : IsTopologicalBasis {s | IsClopen s}
x y : α
hxy : x ≠ y
⊢ ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ univ ⊆ u ∪ v ∧ Disjoint u v

tactic: exact ⟨U, Uᶜ, hU.isOpen, hU.compl.isOpen, hxU, fun h => hyU h rfl, (union_compl_self U).superset,
  disjoint_compl_right⟩
state_before: case isTotallySeparated_univ.intro.intro.intro
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
h : IsTopologicalBasis {s | IsClopen s}
x y : α
hxy : x ≠ y
U : Set α
hU : U ∈ {s | IsClopen s}
hxU : x ∈ U
hyU : U ⊆ {y_1 | y_1 ≠ y}
⊢ ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ univ ⊆ u ∪ v ∧ Disjoint u v
Theorem: Set.image_image2
File: Mathlib/Data/Set/NAry.lean

tactic: ext
state_before: α : Type u_3
α' : Type ?u.33366
β : Type u_4
β' : Type ?u.33372
γ : Type u_2
γ' : Type ?u.33378
δ : Type u_1
δ' : Type ?u.33384
ε : Type ?u.33387
ε' : Type ?u.33390
ζ : Type ?u.33393
ζ' : Type ?u.33396
ν : Type ?u.33399
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → β → γ
g : γ → δ
⊢ g '' image2 f s t = image2 (fun a b => g (f a b)) s t

tactic: constructor
state_before: case h
α : Type u_3
α' : Type ?u.33366
β : Type u_4
β' : Type ?u.33372
γ : Type u_2
γ' : Type ?u.33378
δ : Type u_1
δ' : Type ?u.33384
ε : Type ?u.33387
ε' : Type ?u.33390
ζ : Type ?u.33393
ζ' : Type ?u.33396
ν : Type ?u.33399
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → β → γ
g : γ → δ
x✝ : δ
⊢ x✝ ∈ g '' image2 f s t ↔ x✝ ∈ image2 (fun a b => g (f a b)) s t

tactic: rintro ⟨_, ⟨a, b, ha, hb, rfl⟩, rfl⟩
state_before: case h.mp
α : Type u_3
α' : Type ?u.33366
β : Type u_4
β' : Type ?u.33372
γ : Type u_2
γ' : Type ?u.33378
δ : Type u_1
δ' : Type ?u.33384
ε : Type ?u.33387
ε' : Type ?u.33390
ζ : Type ?u.33393
ζ' : Type ?u.33396
ν : Type ?u.33399
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → β → γ
g : γ → δ
x✝ : δ
⊢ x✝ ∈ g '' image2 f s t → x✝ ∈ image2 (fun a b => g (f a b)) s t

tactic: refine' ⟨a, b, ha, hb, rfl⟩
state_before: case h.mp.intro.intro.intro.intro.intro.intro
α : Type u_3
α' : Type ?u.33366
β : Type u_4
β' : Type ?u.33372
γ : Type u_2
γ' : Type ?u.33378
δ : Type u_1
δ' : Type ?u.33384
ε : Type ?u.33387
ε' : Type ?u.33390
ζ : Type ?u.33393
ζ' : Type ?u.33396
ν : Type ?u.33399
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a✝ a' : α
b✝ b' : β
c c' : γ
d d' : δ
f : α → β → γ
g : γ → δ
a : α
b : β
ha : a ∈ s
hb : b ∈ t
⊢ g (f a b) ∈ image2 (fun a b => g (f a b)) s t

tactic: rintro ⟨a, b, ha, hb, rfl⟩
state_before: case h.mpr
α : Type u_3
α' : Type ?u.33366
β : Type u_4
β' : Type ?u.33372
γ : Type u_2
γ' : Type ?u.33378
δ : Type u_1
δ' : Type ?u.33384
ε : Type ?u.33387
ε' : Type ?u.33390
ζ : Type ?u.33393
ζ' : Type ?u.33396
ν : Type ?u.33399
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → β → γ
g : γ → δ
x✝ : δ
⊢ x✝ ∈ image2 (fun a b => g (f a b)) s t → x✝ ∈ g '' image2 f s t

tactic: refine' ⟨_, ⟨a, b, ha, hb, rfl⟩, rfl⟩
state_before: case h.mpr.intro.intro.intro.intro
α : Type u_3
α' : Type ?u.33366
β : Type u_4
β' : Type ?u.33372
γ : Type u_2
γ' : Type ?u.33378
δ : Type u_1
δ' : Type ?u.33384
ε : Type ?u.33387
ε' : Type ?u.33390
ζ : Type ?u.33393
ζ' : Type ?u.33396
ν : Type ?u.33399
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a✝ a' : α
b✝ b' : β
c c' : γ
d d' : δ
f : α → β → γ
g : γ → δ
a : α
b : β
ha : a ∈ s
hb : b ∈ t
⊢ (fun a b => g (f a b)) a b ∈ g '' image2 f s t
Theorem: Finset.mem_powersetLen
File: Mathlib/Data/Finset/Powerset.lean

tactic: cases s
state_before: α : Type u_1
s✝ t✝ : Finset α
n : ℕ
s t : Finset α
⊢ s ∈ powersetLen n t ↔ s ⊆ t ∧ card s = n

tactic: simp [powersetLen, val_le_iff.symm]
state_before: case mk
α : Type u_1
s t✝ : Finset α
n : ℕ
t : Finset α
val✝ : Multiset α
nodup✝ : Nodup val✝
⊢ { val := val✝, nodup := nodup✝ } ∈ powersetLen n t ↔
    { val := val✝, nodup := nodup✝ } ⊆ t ∧ card { val := val✝, nodup := nodup✝ } = n
Theorem: Set.preimage_const_mul_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iic, h]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x x_1 => x * x_1) c ⁻¹' Ioc a b = Ioc (a / c) (b / c)
Theorem: LinearMap.trace_comp_comm
File: Mathlib/LinearAlgebra/Trace.lean

tactic: apply
  (compl₁₂_inj (show Surjective (dualTensorHom R N M) from (dualTensorHomEquiv R N M).surjective)
      (show Surjective (dualTensorHom R M N) from (dualTensorHomEquiv R M N).surjective)).1
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.549538
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
⊢ compr₂ (llcomp R M N M) (trace R M) = compr₂ (flip (llcomp R N M N)) (trace R N)

tactic: ext (g m f n)
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.549538
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
⊢ compl₁₂ (compr₂ (llcomp R M N M) (trace R M)) (dualTensorHom R N M) (dualTensorHom R M N) =
    compl₁₂ (compr₂ (flip (llcomp R N M N)) (trace R N)) (dualTensorHom R N M) (dualTensorHom R M N)

tactic: simp only [AlgebraTensorModule.curry_apply_apply, compl₁₂_apply, compr₂_apply, llcomp_apply',
  comp_dualTensorHom, map_smulₛₗ, RingHom.id_apply, trace_eq_contract_apply, contractLeft_apply,
  smul_eq_mul, mul_comm, flip_apply]
state_before: case a.h.h.a.h.h
R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.549538
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
g : Module.Dual R N
m : M
f : Module.Dual R M
n : N
⊢ ↑(↑(AlgebraTensorModule.curry
              (↑(↑(AlgebraTensorModule.curry
                        (compl₁₂ (compr₂ (llcomp R M N M) (trace R M)) (dualTensorHom R N M) (dualTensorHom R M N)))
                    g)
                m))
          f)
      n =
    ↑(↑(AlgebraTensorModule.curry
              (↑(↑(AlgebraTensorModule.curry
                        (compl₁₂ (compr₂ (flip (llcomp R N M N)) (trace R N)) (dualTensorHom R N M)
                          (dualTensorHom R M N)))
                    g)
                m))
          f)
      n
Theorem: ContinuousMultilinearMap.le_op_norm_mul_pow_card_of_le
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: simpa only [prod_const] using f.le_op_norm_mul_prod_of_le m hm
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁷ : Fintype ι
inst✝¹⁶ : Fintype ι'
inst✝¹⁵ : NontriviallyNormedField 𝕜
inst✝¹⁴ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹³ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹² : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝¹⁰ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁹ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁸ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁷ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type ?u.521248
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
b : ℝ
hm : ∀ (i : ι), ‖m i‖ ≤ b
⊢ ‖↑f m‖ ≤ ‖f‖ * b ^ Fintype.card ι
Theorem: Submonoid.LocalizationMap.mul_inv_left
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mul_comm]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.325903
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)
y : { x // x ∈ S }
w z : N
⊢ w * ↑(↑(IsUnit.liftRight (MonoidHom.restrict f S) h) y)⁻¹ = z ↔ w = ↑f ↑y * z

tactic: exact Units.inv_mul_eq_iff_eq_mul (IsUnit.liftRight (f.restrict S) h y)
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.325903
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)
y : { x // x ∈ S }
w z : N
⊢ ↑(↑(IsUnit.liftRight (MonoidHom.restrict f S) h) y)⁻¹ * w = z ↔ w = ↑f ↑y * z
Theorem: IsROrC.one_im
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← ofReal_one, ofReal_im]
state_before: K : Type u_1
E : Type ?u.1656730
inst✝ : IsROrC K
⊢ ↑im 1 = 0
Theorem: Traversable.traverse_comp
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: ext
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → F β
h : β → G γ
⊢ traverse (Comp.mk ∘ map h ∘ g) = Comp.mk ∘ map (traverse h) ∘ traverse g

tactic: exact comp_traverse _ _ _
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → F β
h : β → G γ
x✝ : t α
⊢ traverse (Comp.mk ∘ map h ∘ g) x✝ = (Comp.mk ∘ map (traverse h) ∘ traverse g) x✝
Theorem: SimpleGraph.set_walk_self_length_zero_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: ext p
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
⊢ {p | Walk.length p = 0} = {Walk.nil}

tactic: simp
state_before: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
p : Walk G u u
⊢ p ∈ {p | Walk.length p = 0} ↔ p ∈ {Walk.nil}
Theorem: List.exists_of_eraseP
File: Std/Data/List/Lemmas.lean

tactic: simp [pb]
state_before: α : Type u_1
p : α → Bool
b : α
l : List α
a : α
al : a ∈ b :: l
pa : p a = true
pb : p b = true
⊢ b :: l = [] ++ b :: l ∧ eraseP p (b :: l) = [] ++ l

tactic: rw [h₃, cons_append]
state_before: α : Type u_1
p : α → Bool
b✝ : α
l : List α
a : α
al✝ : a ∈ b✝ :: l
pa : p a = true
b : α
al : Mem a l
pb : ¬p b = true
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ b :: l = b :: l₁ ++ c :: l₂

tactic: simp [pb, h₄]
state_before: α : Type u_1
p : α → Bool
b✝ : α
l : List α
a : α
al✝ : a ∈ b✝ :: l
pa : p a = true
b : α
al : Mem a l
pb : ¬p b = true
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ eraseP p (b :: l) = b :: l₁ ++ l₂
Theorem: MonoidHom.ker_eq_bot_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rwa [eq_iff, h, mem_bot, inv_mul_eq_one, eq_comm] at hxy
state_before: G : Type u_1
G' : Type ?u.530012
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.530021
inst✝³ : AddGroup A
N : Type ?u.530027
P : Type ?u.530030
inst✝² : Group N
inst✝¹ : Group P
K : Subgroup G
M : Type u_2
inst✝ : MulOneClass M
f : G →* M
h : ker f = ⊥
x y : G
hxy : ↑f x = ↑f y
⊢ x = y
Theorem: integrableOn_Ioi_cpow_of_lt
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

tactic: rw [IntegrableOn, ← integrable_norm_iff, ← IntegrableOn]
state_before: a : ℂ
ha : a.re < -1
c : ℝ
hc : 0 < c
⊢ IntegrableOn (fun t => ↑t ^ a) (Ioi c)

tactic: refine' (integrableOn_Ioi_rpow_of_lt ha hc).congr_fun (fun x hx => _) measurableSet_Ioi
state_before: a : ℂ
ha : a.re < -1
c : ℝ
hc : 0 < c
⊢ IntegrableOn (fun a_1 => ‖↑a_1 ^ a‖) (Ioi c)

a : ℂ
ha : a.re < -1
c : ℝ
hc : 0 < c
⊢ AEStronglyMeasurable (fun t => ↑t ^ a) (Measure.restrict volume (Ioi c))

tactic: dsimp only
state_before: a : ℂ
ha : a.re < -1
c : ℝ
hc : 0 < c
x : ℝ
hx : x ∈ Ioi c
⊢ x ^ a.re = ‖↑x ^ a‖

tactic: rw [Complex.norm_eq_abs, Complex.abs_cpow_eq_rpow_re_of_pos (hc.trans hx)]
state_before: a : ℂ
ha : a.re < -1
c : ℝ
hc : 0 < c
x : ℝ
hx : x ∈ Ioi c
⊢ x ^ a.re = ‖↑x ^ a‖

tactic: refine' ContinuousOn.aestronglyMeasurable (fun t ht => _) measurableSet_Ioi
state_before: a : ℂ
ha : a.re < -1
c : ℝ
hc : 0 < c
⊢ AEStronglyMeasurable (fun t => ↑t ^ a) (Measure.restrict volume (Ioi c))

tactic: exact
  (Complex.continuousAt_ofReal_cpow_const _ _ (Or.inr (hc.trans ht).ne')).continuousWithinAt
state_before: a : ℂ
ha : a.re < -1
c : ℝ
hc : 0 < c
t : ℝ
ht : t ∈ Ioi c
⊢ ContinuousWithinAt (fun t => ↑t ^ a) (Ioi c) t
Theorem: toIocMod_le_toIcoMod_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod, toIocMod, sub_add, sub_le_sub_iff_left, sub_le_iff_le_add, ← add_one_zsmul,
  (zsmul_strictMono_left hp).le_iff_le]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp a b ≤ toIcoMod hp a b + p

tactic: apply (toIocDiv_wcovby_toIcoDiv _ _ _).le_succ
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a b ≤ toIocDiv hp a b + 1
Theorem: lineMap_one_half
File: Mathlib/LinearAlgebra/AffineSpace/MidpointZero.lean

tactic: rw [one_div, lineMap_inv_two]
state_before: R : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : DivisionRing R
inst✝³ : CharZero R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
a b : P
⊢ ↑(lineMap a b) (1 / 2) = midpoint R a b