tasksource/leandojo huggingface dataset:
Theorem: Path.symm_symm
File: Mathlib/Topology/PathConnected.lean

tactic: ext t
state_before: X : Type u_1
Y : Type ?u.109539
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.109554
γ✝ γ : Path x y
⊢ symm (symm γ) = γ

tactic: show γ (σ (σ t)) = γ t
state_before: case a.h
X : Type u_1
Y : Type ?u.109539
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.109554
γ✝ γ : Path x y
t : ↑I
⊢ ↑(symm (symm γ)) t = ↑γ t

tactic: rw [unitInterval.symm_symm]
state_before: case a.h
X : Type u_1
Y : Type ?u.109539
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.109554
γ✝ γ : Path x y
t : ↑I
⊢ ↑γ (σ (σ t)) = ↑γ t
Theorem: LieSubmodule.lie_le_iff
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [lieIdeal_oper_eq_span, LieSubmodule.lieSpan_le]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ⁅I, N⁆ ≤ N' ↔ ∀ (x : L), x ∈ I → ∀ (m : M), m ∈ N → ⁅x, m⁆ ∈ N'

tactic: refine' ⟨fun h x hx m hm => h ⟨⟨x, hx⟩, ⟨m, hm⟩, rfl⟩, _⟩
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ {m | ∃ x n, ⁅↑x, ↑n⁆ = m} ⊆ ↑N' ↔ ∀ (x : L), x ∈ I → ∀ (m : M), m ∈ N → ⁅x, m⁆ ∈ N'

tactic: rintro h _ ⟨⟨x, hx⟩, ⟨m, hm⟩, rfl⟩
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ (∀ (x : L), x ∈ I → ∀ (m : M), m ∈ N → ⁅x, m⁆ ∈ N') → {m | ∃ x n, ⁅↑x, ↑n⁆ = m} ⊆ ↑N'

tactic: exact h x hx m hm
state_before: case intro.mk.intro.mk
R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
h : ∀ (x : L), x ∈ I → ∀ (m : M), m ∈ N → ⁅x, m⁆ ∈ N'
x : L
hx : x ∈ I
m : M
hm : m ∈ N
⊢ ⁅↑{ val := x, property := hx }, ↑{ val := m, property := hm }⁆ ∈ ↑N'
Theorem: Equiv.finsetCongr_trans
File: Mathlib/Data/Finset/Image.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : α ≃ β
e' : β ≃ γ
⊢ (Equiv.finsetCongr e).trans (Equiv.finsetCongr e') = Equiv.finsetCongr (e.trans e')

tactic: simp [-Finset.mem_map, -Equiv.trans_toEmbedding]
state_before: case H.a
α : Type u_1
β : Type u_2
γ : Type u_3
e : α ≃ β
e' : β ≃ γ
x✝ : Finset α
a✝ : γ
⊢ a✝ ∈ ↑((Equiv.finsetCongr e).trans (Equiv.finsetCongr e')) x✝ ↔ a✝ ∈ ↑(Equiv.finsetCongr (e.trans e')) x✝
Theorem: Ultrafilter.compl_not_mem_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: rwa [compl_compl]
state_before: α : Type u
β : Type v
γ : Type ?u.7081
f g : Ultrafilter α
s t : Set α
p q : α → Prop
hsc : ¬sᶜ ∈ f
h : ↑f ⊓ 𝓟 s = ⊥
⊢ ↑f ⊓ 𝓟 (sᶜᶜ) = ⊥
Theorem: pow_right_comm
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [← pow_mul, Nat.mul_comm, pow_mul]
state_before: α : Type ?u.22873
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m n : ℕ
⊢ (a ^ m) ^ n = (a ^ n) ^ m
Theorem: Multiset.mem_lists_iff
File: Mathlib/Data/Fintype/List.lean

tactic: induction s using Quotient.inductionOn
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Multiset α
l : List α
⊢ l ∈ lists s ↔ s = Quotient.mk (isSetoid α) l

tactic: simpa using perm_comm
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l a✝ : List α
⊢ l ∈ lists (Quotient.mk (isSetoid α) a✝) ↔ Quotient.mk (isSetoid α) a✝ = Quotient.mk (isSetoid α) l
Theorem: AddCommGroup.add_modEq_right
File: Mathlib/Algebra/ModEq.lean

tactic: simp [← modEq_sub_iff_add_modEq]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a + b ≡ b [PMOD p] ↔ a ≡ 0 [PMOD p]
Theorem: Std.RBNode.balance1_eq
File: Std/Data/RBMap/WF.lean

tactic: unfold balance1
state_before: α : Type u_1
c : RBColor
n : Nat
l : RBNode α
v : α
r : RBNode α
hl : Balanced l c n
⊢ balance1 l v r = node black l v r

tactic: split <;> first | rfl | match hl with.
state_before: α : Type u_1
c : RBColor
n : Nat
l : RBNode α
v : α
r : RBNode α
hl : Balanced l c n
⊢ (match l, v, r with
    | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
    | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b) =
    node black l v r

tactic: rfl
state_before: case h_3
α : Type u_1
c : RBColor
n : Nat
l : RBNode α
v : α
r : RBNode α
hl : Balanced l c n
x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
⊢ node black l v r = node black l v r

tactic: match hl with.
state_before: case h_2
α : Type u_1
c : RBColor
n : Nat
v : α
r x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
hl : Balanced (node red a✝ x✝¹ (node red b✝ y✝ c✝)) c n
⊢ node red (node black a✝ x✝¹ b✝) y✝ (node black c✝ v r) = node black (node red a✝ x✝¹ (node red b✝ y✝ c✝)) v r
Theorem: CircleDeg1Lift.translationNumber_eq_rat_iff
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: rw [eq_div_iff, mul_comm, ← translationNumber_pow] <;> [skip; exact ne_of_gt (Nat.cast_pos.2 hn)]
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
m : ℤ
n : ℕ
hn : 0 < n
⊢ τ f = ↑m / ↑n ↔ ∃ x, ↑(f ^ n) x = x + ↑m

tactic: exact (f ^ n).translationNumber_eq_int_iff (f.continuous_pow hf n)
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
m : ℤ
n : ℕ
hn : 0 < n
⊢ τ (f ^ n) = ↑m ↔ ∃ x, ↑(f ^ n) x = x + ↑m
Theorem: Sum.LiftRel.mono
File: Mathlib/Data/Sum/Basic.lean

tactic: cases h
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r r₁ r₂ : α → γ → Prop
s s₁ s₂ : β → δ → Prop
a : α
b : β
c : γ
d : δ
x : α ⊕ β
y : γ ⊕ δ
hr : ∀ (a : α) (b : γ), r₁ a b → r₂ a b
hs : ∀ (a : β) (b : δ), s₁ a b → s₂ a b
h : LiftRel r₁ s₁ x y
⊢ LiftRel r₂ s₂ x y

tactic: exact LiftRel.inl (hr _ _ ‹_›)
state_before: case inl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r r₁ r₂ : α → γ → Prop
s s₁ s₂ : β → δ → Prop
a : α
b : β
c : γ
d : δ
hr : ∀ (a : α) (b : γ), r₁ a b → r₂ a b
hs : ∀ (a : β) (b : δ), s₁ a b → s₂ a b
a✝¹ : α
c✝ : γ
a✝ : r₁ a✝¹ c✝
⊢ LiftRel r₂ s₂ (inl a✝¹) (inl c✝)

tactic: exact LiftRel.inr (hs _ _ ‹_›)
state_before: case inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r r₁ r₂ : α → γ → Prop
s s₁ s₂ : β → δ → Prop
a : α
b : β
c : γ
d : δ
hr : ∀ (a : α) (b : γ), r₁ a b → r₂ a b
hs : ∀ (a : β) (b : δ), s₁ a b → s₂ a b
b✝ : β
d✝ : δ
a✝ : s₁ b✝ d✝
⊢ LiftRel r₂ s₂ (inr b✝) (inr d✝)
Theorem: Quiver.Path.cast_eq_cast
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [hu, hv]
state_before: U : Type ?u.1452
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ Path u v = Path u' v'

tactic: subst_vars
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ cast hu hv p = _root_.cast (_ : Path u v = Path u' v') p

tactic: rfl
state_before: U : Type u_1
inst✝ : Quiver U
u' v' : U
p : Path u' v'
⊢ cast (_ : u' = u') (_ : v' = v') p = _root_.cast (_ : Path u' v' = Path u' v') p
Theorem: isLeftRegular_of_mul_eq_one
File: Mathlib/Algebra/Regular/Basic.lean

tactic: rw [h]
state_before: R : Type u_1
inst✝ : Monoid R
a b : R
h : b * a = 1
⊢ IsLeftRegular (?m.13569 h * a)

tactic: exact isRegular_one.left
state_before: R : Type u_1
inst✝ : Monoid R
a b : R
h : b * a = 1
⊢ IsLeftRegular 1
Theorem: SimpleGraph.Walk.IsPath.of_append_right
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← isPath_reverse_iff] at h ⊢
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
q : Walk G v w
h : IsPath (append p q)
⊢ IsPath q

tactic: rw [reverse_append] at h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
q : Walk G v w
h : IsPath (Walk.reverse (append p q))
⊢ IsPath (Walk.reverse q)

tactic: apply h.of_append_left
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
q : Walk G v w
h : IsPath (append (Walk.reverse q) (Walk.reverse p))
⊢ IsPath (Walk.reverse q)
Theorem: Ordnode.dual_node4L
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases m <;> simp [node4L, node4R, node3R, dual_node3L, dual_node', add_comm]
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ dual (node4L l x m y r) = node4R (dual r) y (dual m) x (dual l)
Theorem: Sym2.eq_iff
File: Mathlib/Data/Sym/Sym2.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.5214
γ : Type ?u.5217
x y z w : α
⊢ Quotient.mk (Rel.setoid α) (x, y) = Quotient.mk (Rel.setoid α) (z, w) ↔ x = z ∧ y = w ∨ x = w ∧ y = z
Theorem: EuclideanGeometry.Sphere.ne_iff
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

tactic: rw [← not_and_or, ← Sphere.ext_iff]
state_before: V : Type ?u.4284
P : Type u_1
inst✝ : MetricSpace P
s₁ s₂ : Sphere P
⊢ s₁ ≠ s₂ ↔ s₁.center ≠ s₂.center ∨ s₁.radius ≠ s₂.radius
Theorem: iSup_extend_bot
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iSup_split _ fun j => ∃ i, e i = j]
state_before: α : Type u_3
β : Type u_2
β₂ : Type ?u.142989
γ : Type ?u.142992
ι : Sort u_1
ι' : Sort ?u.142998
κ : ι → Sort ?u.143003
κ' : ι' → Sort ?u.143008
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
e : ι → β
he : Injective e
f : ι → α
⊢ (⨆ (j : β), extend e f ⊥ j) = ⨆ (i : ι), f i

tactic: simp (config := { contextual := true }) [he.extend_apply, extend_apply', @iSup_comm _ β ι]
state_before: α : Type u_3
β : Type u_2
β₂ : Type ?u.142989
γ : Type ?u.142992
ι : Sort u_1
ι' : Sort ?u.142998
κ : ι → Sort ?u.143003
κ' : ι' → Sort ?u.143008
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
e : ι → β
he : Injective e
f : ι → α
⊢ ((⨆ (i : β) (_ : ∃ i_1, e i_1 = i), extend e f ⊥ i) ⊔ ⨆ (i : β) (_ : ¬∃ i_1, e i_1 = i), extend e f ⊥ i) =
    ⨆ (i : ι), f i
Theorem: Set.Ioc_inter_Ioi
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← Ioi_inter_Iic, inter_assoc, inter_comm, inter_assoc, Ioi_inter_Ioi, inter_comm,
  Ioi_inter_Iic, sup_comm]
state_before: α : Type u_1
β : Type ?u.204029
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∩ Ioi c = Ioc (a ⊔ c) b
Theorem: HahnSeries.support_mul_subset_add_support
File: Mathlib/RingTheory/HahnSeries.lean

tactic: apply Set.Subset.trans (fun x hx => _) support_addAntidiagonal_subset_add
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
⊢ support (x * y) ⊆ support x + support y

tactic: intro x hx
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
⊢ ∀ (x_1 : Γ),
    x_1 ∈ support (x * y) →
      x_1 ∈ {a | Finset.Nonempty (addAntidiagonal (_ : Set.IsPwo (support x)) (_ : Set.IsPwo (support y)) a)}

tactic: contrapose! hx
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x✝ y : HahnSeries Γ R
x : Γ
hx : x ∈ support (x✝ * y)
⊢ x ∈ {a | Finset.Nonempty (addAntidiagonal (_ : Set.IsPwo (support x✝)) (_ : Set.IsPwo (support y)) a)}

tactic: simp only [not_nonempty_iff_eq_empty, Ne.def, Set.mem_setOf_eq] at hx
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x✝ y : HahnSeries Γ R
x : Γ
hx : ¬x ∈ {a | Finset.Nonempty (addAntidiagonal (_ : Set.IsPwo (support x✝)) (_ : Set.IsPwo (support y)) a)}
⊢ ¬x ∈ support (x✝ * y)

tactic: simp [hx, mul_coeff]
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x✝ y : HahnSeries Γ R
x : Γ
hx : addAntidiagonal (_ : Set.IsPwo (support x✝)) (_ : Set.IsPwo (support y)) x = ∅
⊢ ¬x ∈ support (x✝ * y)

tactic: exact x.isPwo_support
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
⊢ Set.IsPwo (support x)

tactic: exact y.isPwo_support
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
⊢ Set.IsPwo (support y)
Theorem: Nat.decreasingInduction_trans
File: Mathlib/Data/Nat/Basic.lean

tactic: induction' nk with k nk ih
state_before: m✝ n✝ k✝ : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
m n k : ℕ
mn : m ≤ n
nk : n ≤ k
hP : P k
⊢ decreasingInduction h (_ : m ≤ k) hP = decreasingInduction h mn (decreasingInduction h nk hP)

tactic: rw [decreasingInduction_self]
state_before: case refl
m✝ n✝ k✝ : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
m n k : ℕ
mn : m ≤ n
hP✝ : P k
hP : P n
⊢ decreasingInduction h (_ : m ≤ n) hP = decreasingInduction h mn (decreasingInduction h (_ : Nat.le n n) hP)

tactic: rw [decreasingInduction_succ h (le_trans mn nk), ih, decreasingInduction_succ]
state_before: case step
m✝ n✝ k✝¹ : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
m n k✝ : ℕ
mn : m ≤ n
hP✝ : P k✝
k : ℕ
nk : Nat.le n k
ih : ∀ (hP : P k), decreasingInduction h (_ : m ≤ k) hP = decreasingInduction h mn (decreasingInduction h nk hP)
hP : P (succ k)
⊢ decreasingInduction h (_ : m ≤ succ k) hP =
    decreasingInduction h mn (decreasingInduction h (_ : Nat.le n (succ k)) hP)
Theorem: Ordinal.unbounded_of_unbounded_iUnion
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← sUnion_range] at h₁
state_before: α✝ : Type ?u.108841
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃ (x : β), s x)
h₂ : (#β) < StrictOrder.cof r
⊢ ∃ x, Unbounded r (s x)

tactic: rcases unbounded_of_unbounded_sUnion r h₁ (mk_range_le.trans_lt h₂) with ⟨_, ⟨x, rfl⟩, u⟩
state_before: α✝ : Type ?u.108841
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃₀ range fun x => s x)
h₂ : (#β) < StrictOrder.cof r
⊢ ∃ x, Unbounded r (s x)

tactic: exact ⟨x, u⟩
state_before: case intro.intro.intro
α✝ : Type ?u.108841
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃₀ range fun x => s x)
h₂ : (#β) < StrictOrder.cof r
x : β
u : Unbounded r ((fun x => s x) x)
⊢ ∃ x, Unbounded r (s x)
Theorem: Set.range_dcomp
File: Mathlib/Data/Set/Prod.lean

tactic: refine Subset.antisymm ?_ fun x hx => ?_
state_before: ι : Type u_1
α : ι → Type u_3
β : ι → Type u_2
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
f : (i : ι) → α i → β i
⊢ (range fun g i => f i (g i)) = pi univ fun i => range (f i)

tactic: rintro _ ⟨x, rfl⟩ i -
state_before: case refine_1
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_2
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
f : (i : ι) → α i → β i
⊢ (range fun g i => f i (g i)) ⊆ pi univ fun i => range (f i)

tactic: exact ⟨x i, rfl⟩
state_before: case refine_1.intro
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_2
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i✝ : ι
f : (i : ι) → α i → β i
x : (i : ι) → α i
i : ι
⊢ (fun g i => f i (g i)) x i ∈ (fun i => range (f i)) i

tactic: choose y hy using hx
state_before: case refine_2
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_2
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
f : (i : ι) → α i → β i
x : (i : ι) → β i
hx : x ∈ pi univ fun i => range (f i)
⊢ x ∈ range fun g i => f i (g i)

tactic: exact ⟨fun i => y i trivial, funext fun i => hy i trivial⟩
state_before: case refine_2
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_2
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
f : (i : ι) → α i → β i
x : (i : ι) → β i
y : (i : ι) → i ∈ univ → α i
hy : ∀ (i : ι) (a : i ∈ univ), f i (y i a) = x i
⊢ x ∈ range fun g i => f i (g i)
Theorem: OreLocalization.mul_cancel
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [oreDiv_mul_char r s s t 1 1 (by simp)]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
s t : { x // x ∈ S }
⊢ r /ₒ s * (↑s /ₒ t) = r /ₒ t

tactic: simp
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
s t : { x // x ∈ S }
⊢ ↑s * ↑1 = ↑s * 1
Theorem: MeasureTheory.analyticSet_range_of_polishSpace
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: cases isEmpty_or_nonempty β
state_before: α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.684
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
f : β → α
f_cont : Continuous f
⊢ AnalyticSet (range f)

tactic: rw [range_eq_empty]
state_before: case inl
α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.684
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
f : β → α
f_cont : Continuous f
h✝ : IsEmpty β
⊢ AnalyticSet (range f)

tactic: exact analyticSet_empty
state_before: case inl
α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.684
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
f : β → α
f_cont : Continuous f
h✝ : IsEmpty β
⊢ AnalyticSet ∅

tactic: rw [AnalyticSet]
state_before: case inr
α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.684
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
f : β → α
f_cont : Continuous f
h✝ : Nonempty β
⊢ AnalyticSet (range f)

tactic: obtain ⟨g, g_cont, hg⟩ : ∃ g : (ℕ → ℕ) → β, Continuous g ∧ Surjective g :=
  exists_nat_nat_continuous_surjective β
state_before: case inr
α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.684
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
f : β → α
f_cont : Continuous f
h✝ : Nonempty β
⊢ range f = ∅ ∨ ∃ f_1, Continuous f_1 ∧ range f_1 = range f

tactic: refine' Or.inr ⟨f ∘ g, f_cont.comp g_cont, _⟩
state_before: case inr.intro.intro
α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.684
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
f : β → α
f_cont : Continuous f
h✝ : Nonempty β
g : (ℕ → ℕ) → β
g_cont : Continuous g
hg : Surjective g
⊢ range f = ∅ ∨ ∃ f_1, Continuous f_1 ∧ range f_1 = range f

tactic: rw [hg.range_comp]
state_before: case inr.intro.intro
α : Type u_2
inst✝² : TopologicalSpace α
ι : Type ?u.684
β : Type u_1
inst✝¹ : TopologicalSpace β
inst✝ : PolishSpace β
f : β → α
f_cont : Continuous f
h✝ : Nonempty β
g : (ℕ → ℕ) → β
g_cont : Continuous g
hg : Surjective g
⊢ range (f ∘ g) = range f
Theorem: MeasureTheory.integral_finset_sum
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_3
E : Type u_2
F : Type ?u.898484
𝕜 : Type ?u.898487
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
ι : Type u_1
s : Finset ι
f : ι → α → E
hf : ∀ (i : ι), i ∈ s → Integrable (f i)
⊢ (∫ (a : α), ∑ i in s, f i a ∂μ) = ∑ i in s, ∫ (a : α), f i a ∂μ

tactic: exact setToFun_finset_sum (dominatedFinMeasAdditive_weightedSMul _) s hf
state_before: α : Type u_3
E : Type u_2
F : Type ?u.898484
𝕜 : Type ?u.898487
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
ι : Type u_1
s : Finset ι
f : ι → α → E
hf : ∀ (i : ι), i ∈ s → Integrable (f i)
⊢ (if hf : Integrable fun a => ∑ i in s, f i a then ↑L1.integralCLM (Integrable.toL1 (fun a => ∑ i in s, f i a) hf)
    else 0) =
    ∑ x in s, if hf : Integrable fun a => f x a then ↑L1.integralCLM (Integrable.toL1 (fun a => f x a) hf) else 0
Theorem: Subsemigroup.closure_closure_coe_preimage
File: Mathlib/GroupTheory/Subsemigroup/Operations.lean

tactic: refine' closure_induction' _ (fun g hg => subset_closure hg) (fun g₁ g₂ hg₁ hg₂ => _) hx
state_before: M : Type u_1
N : Type ?u.47324
P : Type ?u.47327
σ : Type ?u.47330
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
s : Set M
x✝¹ : { x // x ∈ closure s }
x : M
hx : x ∈ closure s
x✝ : { val := x, property := hx } ∈ ⊤
⊢ { val := x, property := hx } ∈ closure (Subtype.val ⁻¹' s)

tactic: exact Subsemigroup.mul_mem _
state_before: M : Type u_1
N : Type ?u.47324
P : Type ?u.47327
σ : Type ?u.47330
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
s : Set M
x✝¹ : { x // x ∈ closure s }
x : M
hx : x ∈ closure s
x✝ : { val := x, property := hx } ∈ ⊤
g₁ : M
g₂ : g₁ ∈ closure s
hg₁ : M
hg₂ : hg₁ ∈ closure s
⊢ { val := g₁, property := g₂ } ∈ closure (Subtype.val ⁻¹' s) →
    { val := hg₁, property := hg₂ } ∈ closure (Subtype.val ⁻¹' s) →
      { val := g₁ * hg₁, property := (_ : g₁ * hg₁ ∈ closure s) } ∈ closure (Subtype.val ⁻¹' s)
Theorem: norm_add_eq_sqrt_iff_real_inner_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← norm_add_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero, eq_comm,
  sqrt_eq_iff_mul_self_eq (add_nonneg (mul_self_nonneg _) (mul_self_nonneg _)) (norm_nonneg _)]
state_before: 𝕜 : Type ?u.3106316
E : Type ?u.3106319
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ ‖x + y‖ = sqrt (‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) ↔ inner x y = 0
Theorem: Prod.map_injective
File: Mathlib/Data/Prod/Basic.lean

tactic: inhabit β
state_before: α : Type u_1
β : Type u_2
γ : Type u_4
δ : Type u_3
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
a₁ a₂ : α
ha : f a₁ = f a₂
⊢ a₁ = a₂

tactic: injection
  @h (a₁, default) (a₂, default) (congr_arg (fun c : γ => Prod.mk c (g default)) ha : _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_4
δ : Type u_3
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
a₁ a₂ : α
ha : f a₁ = f a₂
inhabited_h : Inhabited β
⊢ a₁ = a₂

tactic: inhabit α
state_before: α : Type u_1
β : Type u_2
γ : Type u_4
δ : Type u_3
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
b₁ b₂ : β
hb : g b₁ = g b₂
⊢ b₁ = b₂

tactic: injection @h (default, b₁) (default, b₂) (congr_arg (Prod.mk (f default)) hb : _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_4
δ : Type u_3
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
b₁ b₂ : β
hb : g b₁ = g b₂
inhabited_h : Inhabited α
⊢ b₁ = b₂