tasksource/leandojo huggingface dataset:
Theorem: OpenEmbedding.isQuasiSeparated_iff
File: Mathlib/Topology/QuasiSeparated.lean

tactic: refine' ⟨fun hs => hs.image_of_embedding h.toEmbedding, _⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
h : OpenEmbedding f
s : Set α
⊢ IsQuasiSeparated s ↔ IsQuasiSeparated (f '' s)

tactic: intro H U V hU hU' hU'' hV hV' hV''
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
h : OpenEmbedding f
s : Set α
⊢ IsQuasiSeparated (f '' s) → IsQuasiSeparated s

tactic: rw [h.toEmbedding.isCompact_iff_isCompact_image, Set.image_inter h.inj]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
h : OpenEmbedding f
s : Set α
H : IsQuasiSeparated (f '' s)
U V : Set α
hU : U ⊆ s
hU' : IsOpen U
hU'' : IsCompact U
hV : V ⊆ s
hV' : IsOpen V
hV'' : IsCompact V
⊢ IsCompact (U ∩ V)

tactic: exact
  H (f '' U) (f '' V) (Set.image_subset _ hU) (h.isOpenMap _ hU') (hU''.image h.continuous)
    (Set.image_subset _ hV) (h.isOpenMap _ hV') (hV''.image h.continuous)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
h : OpenEmbedding f
s : Set α
H : IsQuasiSeparated (f '' s)
U V : Set α
hU : U ⊆ s
hU' : IsOpen U
hU'' : IsCompact U
hV : V ⊆ s
hV' : IsOpen V
hV'' : IsCompact V
⊢ IsCompact (f '' U ∩ f '' V)
Theorem: Subgroup.fg_iff_add_fg
File: Mathlib/GroupTheory/Finiteness.lean

tactic: rw [Subgroup.fg_iff_submonoid_fg, AddSubgroup.fg_iff_addSubmonoid_fg]
state_before: M : Type ?u.71766
N : Type ?u.71769
inst✝³ : Monoid M
inst✝² : AddMonoid N
G : Type u_1
H : Type ?u.71781
inst✝¹ : Group G
inst✝ : AddGroup H
P : Subgroup G
⊢ FG P ↔ AddSubgroup.FG (↑toAddSubgroup P)

tactic: exact (Subgroup.toSubmonoid P).fg_iff_add_fg
state_before: M : Type ?u.71766
N : Type ?u.71769
inst✝³ : Monoid M
inst✝² : AddMonoid N
G : Type u_1
H : Type ?u.71781
inst✝¹ : Group G
inst✝ : AddGroup H
P : Subgroup G
⊢ Submonoid.FG P.toSubmonoid ↔ AddSubmonoid.FG (↑toAddSubgroup P).toAddSubmonoid
Theorem: Filter.rcomap_rcomap
File: Mathlib/Order/Filter/Partial.lean

tactic: ext t
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
⊢ (rcomap r (rcomap s l)).sets = (rcomap (Rel.comp r s) l).sets

tactic: simp [rcomap_sets, Rel.image, Rel.core_comp]
state_before: case h
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ t ∈ (rcomap r (rcomap s l)).sets ↔ t ∈ (rcomap (Rel.comp r s) l).sets

tactic: constructor
state_before: case h
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ (∃ x, (∃ x_1, x_1 ∈ l ∧ Rel.core s x_1 ⊆ x) ∧ Rel.core r x ⊆ t) ↔ ∃ x, x ∈ l ∧ Rel.core r (Rel.core s x) ⊆ t

tactic: rintro ⟨t, tsets, ht⟩
state_before: case h.mpr
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ (∃ x, x ∈ l ∧ Rel.core r (Rel.core s x) ⊆ t) → ∃ x, (∃ x_1, x_1 ∈ l ∧ Rel.core s x_1 ⊆ x) ∧ Rel.core r x ⊆ t

tactic: exact ⟨Rel.core s t, ⟨t, tsets, Set.Subset.rfl⟩, ht⟩
state_before: case h.mpr.intro.intro
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t✝ : Set α
t : Set γ
tsets : t ∈ l
ht : Rel.core r (Rel.core s t) ⊆ t✝
⊢ ∃ x, (∃ x_1, x_1 ∈ l ∧ Rel.core s x_1 ⊆ x) ∧ Rel.core r x ⊆ t✝

tactic: rintro ⟨u, ⟨v, vsets, hv⟩, h⟩
state_before: case h.mp
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
⊢ (∃ x, (∃ x_1, x_1 ∈ l ∧ Rel.core s x_1 ⊆ x) ∧ Rel.core r x ⊆ t) → ∃ x, x ∈ l ∧ Rel.core r (Rel.core s x) ⊆ t

tactic: exact ⟨v, vsets, Set.Subset.trans (Rel.core_mono _ hv) h⟩
state_before: case h.mp.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
r : Rel α β
s : Rel β γ
l : Filter γ
t : Set α
u : Set β
h : Rel.core r u ⊆ t
v : Set γ
vsets : v ∈ l
hv : Rel.core s v ⊆ u
⊢ ∃ x, x ∈ l ∧ Rel.core r (Rel.core s x) ⊆ t
Theorem: CategoryTheory.Idempotents.isIdempotentComplete_iff_opposite
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

tactic: constructor
state_before: C : Type u_1
inst✝ : Category C
⊢ IsIdempotentComplete Cᵒᵖ ↔ IsIdempotentComplete C

tactic: exact isIdempotentComplete_of_isIdempotentComplete_opposite
state_before: case mp
C : Type u_1
inst✝ : Category C
⊢ IsIdempotentComplete Cᵒᵖ → IsIdempotentComplete C

tactic: intro h
state_before: case mpr
C : Type u_1
inst✝ : Category C
⊢ IsIdempotentComplete C → IsIdempotentComplete Cᵒᵖ

tactic: apply isIdempotentComplete_of_isIdempotentComplete_opposite
state_before: case mpr
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete Cᵒᵖ

tactic: rw [isIdempotentComplete_iff_of_equivalence (opOpEquivalence C)]
state_before: case mpr.h
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete Cᵒᵖᵒᵖ

tactic: exact h
state_before: case mpr.h
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete C
⊢ IsIdempotentComplete C
Theorem: Valuation.isEquiv_iff_val_le_one
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: simpa using h x 1
state_before: K : Type u_3
F : Type ?u.3206204
R : Type ?u.3206207
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type u_2
Γ''₀ : Type ?u.3206219
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
h : IsEquiv v v'
x : K
⊢ ↑v x ≤ 1 ↔ ↑v' x ≤ 1
Theorem: Computation.tail_think
File: Mathlib/Data/Seq/Computation.lean

tactic: cases' s with f al
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
⊢ tail (think s) = s

tactic: apply Subtype.eq
state_before: case mk
α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ tail (think { val := f, property := al }) = { val := f, property := al }

tactic: dsimp [tail, think]
state_before: case mk.a
α : Type u
β : Type v
γ : Type w
f : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, f n = some a → f (n + 1) = some a
⊢ ↑(tail (think { val := f, property := al })) = ↑{ val := f, property := al }
Theorem: inner_orthogonalProjection_eq_of_mem_left
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [← inner_conj_symm, ← inner_conj_symm (u : E), inner_orthogonalProjection_eq_of_mem_right]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.979345
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
u : { x // x ∈ K }
v : E
⊢ inner u (↑(orthogonalProjection K) v) = inner (↑u) v
Theorem: ContinuousLinearEquiv.image_symm_eq_preimage
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: rw [e.symm.image_eq_preimage, e.symm_symm]
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type ?u.1603076
inst✝²⁴ : Semiring R₁
inst✝²³ : Semiring R₂
inst✝²² : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₁ : R₂ →+* R₁
inst✝²¹ : RingHomInvPair σ₁₂ σ₂₁
inst✝²⁰ : RingHomInvPair σ₂₁ σ₁₂
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
inst✝¹⁹ : RingHomInvPair σ₂₃ σ₃₂
inst✝¹⁸ : RingHomInvPair σ₃₂ σ₂₃
σ₁₃ : R₁ →+* R₃
σ₃₁ : R₃ →+* R₁
inst✝¹⁷ : RingHomInvPair σ₁₃ σ₃₁
inst✝¹⁶ : RingHomInvPair σ₃₁ σ₁₃
inst✝¹⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁴ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
M₁ : Type u_3
inst✝¹³ : TopologicalSpace M₁
inst✝¹² : AddCommMonoid M₁
M'₁ : Type ?u.1603930
inst✝¹¹ : TopologicalSpace M'₁
inst✝¹⁰ : AddCommMonoid M'₁
M₂ : Type u_4
inst✝⁹ : TopologicalSpace M₂
inst✝⁸ : AddCommMonoid M₂
M₃ : Type ?u.1603948
inst✝⁷ : TopologicalSpace M₃
inst✝⁶ : AddCommMonoid M₃
M₄ : Type ?u.1603957
inst✝⁵ : TopologicalSpace M₄
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R₁ M₁
inst✝² : Module R₁ M'₁
inst✝¹ : Module R₂ M₂
inst✝ : Module R₃ M₃
e : M₁ ≃SL[σ₁₂] M₂
s : Set M₂
⊢ ↑(ContinuousLinearEquiv.symm e) '' s = ↑e ⁻¹' s
Theorem: Doset.disjoint_out'
File: Mathlib/GroupTheory/DoubleCoset.lean

tactic: contrapose!
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.40758
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : Quotient ↑H.toSubmonoid ↑K
⊢ a ≠ b → Disjoint (doset (Quotient.out' a) ↑H ↑K) (doset (Quotient.out' b) ↑H ↑K)

tactic: intro h
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.40758
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : Quotient ↑H.toSubmonoid ↑K
⊢ ¬Disjoint (doset (Quotient.out' a) ↑H ↑K) (doset (Quotient.out' b) ↑H ↑K) → a = b

tactic: simpa [out_eq'] using mk_eq_of_doset_eq (eq_of_not_disjoint h)
state_before: G : Type u_1
inst✝¹ : Group G
α : Type ?u.40758
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : Quotient ↑H.toSubmonoid ↑K
h : ¬Disjoint (doset (Quotient.out' a) ↑H ↑K) (doset (Quotient.out' b) ↑H ↑K)
⊢ a = b
Theorem: Holor.cprankMax_mul
File: Mathlib/Data/Holor.lean

tactic: simp [mul_zero x, CPRankMax.zero]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
x : Holor α [d]
⊢ CPRankMax 0 (x ⊗ 0)

tactic: rw [mul_left_distrib]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : CPRankMax1 y₁
hy₂ : CPRankMax n y₂
⊢ CPRankMax (n + 1) (x ⊗ (y₁ + y₂))

tactic: rw [Nat.add_comm]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : CPRankMax1 y₁
hy₂ : CPRankMax n y₂
⊢ CPRankMax (n + 1) (x ⊗ y₁ + x ⊗ y₂)

tactic: apply cprankMax_add
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : CPRankMax1 y₁
hy₂ : CPRankMax n y₂
⊢ CPRankMax (1 + n) (x ⊗ y₁ + x ⊗ y₂)

tactic: exact cprankMax_1 (CPRankMax1.cons _ _ hy₁)
state_before: case a
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : CPRankMax1 y₁
hy₂ : CPRankMax n y₂
⊢ CPRankMax 1 (x ⊗ y₁)

tactic: exact cprankMax_mul _ x y₂ hy₂
state_before: case a
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
n : ℕ
x : Holor α [d]
y₁ y₂ : Holor α ds
hy₁ : CPRankMax1 y₁
hy₂ : CPRankMax n y₂
⊢ CPRankMax n (x ⊗ y₂)
Theorem: Cardinal.add_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← Nat.cast_add]
state_before: α β : Type u
a b : Cardinal
m n : ℕ
ha : ↑m < ℵ₀
hb : ↑n < ℵ₀
⊢ ↑m + ↑n < ℵ₀

tactic: apply nat_lt_aleph0
state_before: α β : Type u
a b : Cardinal
m n : ℕ
ha : ↑m < ℵ₀
hb : ↑n < ℵ₀
⊢ ↑(m + n) < ℵ₀
Theorem: one_lt_zpow'
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: obtain ⟨n, hn⟩ := Int.eq_ofNat_of_zero_le hk.le
state_before: α : Type u_1
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✝ : OrderedCommGroup α
m n : ℤ
a b : α
ha : 1 < a
k : ℤ
hk : 0 < k
⊢ 1 < a ^ k

tactic: rw [hn, zpow_ofNat]
state_before: case intro
α : Type u_1
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✝ : OrderedCommGroup α
m n✝ : ℤ
a b : α
ha : 1 < a
k : ℤ
hk : 0 < k
n : ℕ
hn : k = ↑n
⊢ 1 < a ^ k

tactic: refine' one_lt_pow' ha (coe_nat_pos.mp _).ne'
state_before: case intro
α : Type u_1
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✝ : OrderedCommGroup α
m n✝ : ℤ
a b : α
ha : 1 < a
k : ℤ
hk : 0 < k
n : ℕ
hn : k = ↑n
⊢ 1 < a ^ n

tactic: rwa [← hn]
state_before: case intro
α : Type u_1
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✝ : OrderedCommGroup α
m n✝ : ℤ
a b : α
ha : 1 < a
k : ℤ
hk : 0 < k
n : ℕ
hn : k = ↑n
⊢ 0 < ↑n
Theorem: AddCommGroup.add_modEq_left
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 ≡ a [PMOD p] ↔ b ≡ 0 [PMOD p]
Theorem: PNat.XgcdType.isSpecial_iff
File: Mathlib/Data/PNat/Xgcd.lean

tactic: dsimp [IsSpecial, IsSpecial']
state_before: u : XgcdType
⊢ IsSpecial u ↔ IsSpecial' u

tactic: let ⟨wp, x, y, zp, ap, bp⟩ := u
state_before: u : XgcdType
⊢ u.wp + u.zp + u.wp * u.zp = u.x * u.y ↔ w u * z u = succPNat (u.x * u.y)

tactic: constructor <;> intro h <;> simp [w, z, succPNat] at * <;>
  simp only [← coe_inj, mul_coe, mk_coe] at *
state_before: u : XgcdType
wp x y zp ap bp : ℕ
⊢ { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.wp +
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.zp +
        { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.wp *
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.zp =
      { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.x *
        { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.y ↔
    w { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp } *
        z { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp } =
      succPNat
        ({ wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.x *
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.y)

tactic: . simp_all [← h, Nat.mul, Nat.succ_eq_add_one]; ring
state_before: case mp
u : XgcdType
wp x y zp ap bp : ℕ
h : wp + zp + wp * zp = x * y
⊢ succ wp * succ zp = succ (x * y)

case mpr
u : XgcdType
wp x y zp ap bp : ℕ
h : succ wp * succ zp = succ (x * y)
⊢ wp + zp + wp * zp = x * y

tactic: . simp [Nat.succ_eq_add_one, Nat.mul_add, Nat.add_mul, ← Nat.add_assoc] at h; rw [← h]; ring
state_before: case mpr
u : XgcdType
wp x y zp ap bp : ℕ
h : succ wp * succ zp = succ (x * y)
⊢ wp + zp + wp * zp = x * y

tactic: simp_all [← h, Nat.mul, Nat.succ_eq_add_one]
state_before: case mp
u : XgcdType
wp x y zp ap bp : ℕ
h : wp + zp + wp * zp = x * y
⊢ succ wp * succ zp = succ (x * y)

tactic: ring
state_before: case mp
u : XgcdType
wp x y zp ap bp : ℕ
⊢ (wp + 1) * (zp + 1) = wp + zp + wp * zp + 1

tactic: simp [Nat.succ_eq_add_one, Nat.mul_add, Nat.add_mul, ← Nat.add_assoc] at h
state_before: case mpr
u : XgcdType
wp x y zp ap bp : ℕ
h : succ wp * succ zp = succ (x * y)
⊢ wp + zp + wp * zp = x * y

tactic: rw [← h]
state_before: case mpr
u : XgcdType
wp x y zp ap bp : ℕ
h : wp * zp + zp + wp = x * y
⊢ wp + zp + wp * zp = x * y

tactic: ring
state_before: case mpr
u : XgcdType
wp x y zp ap bp : ℕ
h : wp * zp + zp + wp = x * y
⊢ wp + zp + wp * zp = wp * zp + zp + wp
Theorem: Equiv.swap_mul_swap_mul_swap
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: simp only [swap_apply_def, Perm.mul_apply]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
x y z : α
hwz : x ≠ y
hxz : x ≠ z
n : α
⊢ ↑(swap y z * swap x y * swap y z) n = ↑(swap z x) n

tactic: split_ifs <;> aesop
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
x y z : α
hwz : x ≠ y
hxz : x ≠ z
n : α
⊢ (if
        (if (if n = y then z else if n = z then y else n) = x then y
          else
            if (if n = y then z else if n = z then y else n) = y then x
            else if n = y then z else if n = z then y else n) =
          y then
      z
    else
      if
          (if (if n = y then z else if n = z then y else n) = x then y
            else
              if (if n = y then z else if n = z then y else n) = y then x
              else if n = y then z else if n = z then y else n) =
            z then
        y
      else
        if (if n = y then z else if n = z then y else n) = x then y
        else
          if (if n = y then z else if n = z then y else n) = y then x
          else if n = y then z else if n = z then y else n) =
    if n = z then x else if n = x then z else n
Theorem: LinearMap.separatingLeft_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: rw [← Matrix.nondegenerate_iff_det_ne_zero, nondegenerate_toMatrix_iff]
state_before: R : Type ?u.2919829
R₁ : Type u_1
R₂ : Type ?u.2919835
M : Type ?u.2919838
M₁ : Type u_2
M₂ : Type ?u.2919844
M₁' : Type ?u.2919847
M₂' : Type ?u.2919850
n : Type ?u.2919853
m : Type ?u.2919856
n' : Type ?u.2919859
m' : Type ?u.2919862
ι : Type u_3
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommMonoid M₁
inst✝³ : Module R₁ M₁
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
B✝ : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁
inst✝ : IsDomain R₁
B : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁
b : Basis ι R₁ M₁
⊢ SeparatingLeft B ↔ det (↑(toMatrix₂ b b) B) ≠ 0
Theorem: Set.Finite.isCompact_sUnion
File: Mathlib/Topology/SubsetProperties.lean

tactic: rw [sUnion_eq_biUnion]
state_before: α : Type u
β : Type v
ι : Type ?u.32535
π : ι → Type ?u.32540
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
S : Set (Set α)
hf : Set.Finite S
hc : ∀ (s : Set α), s ∈ S → IsCompact s
⊢ IsCompact (⋃₀ S)

tactic: exact hf.isCompact_biUnion hc
state_before: α : Type u
β : Type v
ι : Type ?u.32535
π : ι → Type ?u.32540
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
S : Set (Set α)
hf : Set.Finite S
hc : ∀ (s : Set α), s ∈ S → IsCompact s
⊢ IsCompact (⋃ (i : Set α) (_ : i ∈ S), i)
Theorem: Int.mul_ediv_cancel
File: Std/Data/Int/DivMod.lean

tactic: have := Int.add_mul_ediv_right 0 a H
state_before: a b : Int
H : b ≠ 0
⊢ a * b / b = a

tactic: rwa [Int.zero_add, Int.zero_ediv, Int.zero_add] at this
state_before: a b : Int
H : b ≠ 0
this : (0 + a * b) / b = 0 / b + a
⊢ a * b / b = a
Theorem: Std.PairingHeapImp.Heap.noSibling_combine
File: Std/Data/PairingHeap.lean

tactic: unfold combine
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ NoSibling (combine le s)

tactic: split
state_before: α : Type u_1
le : α → α → Bool
s : Heap α
⊢ NoSibling
    (match s with
    | h₁@h_1:(node a child h₂@h:(node a_1 child_1 s)) => merge le (merge le h₁ h₂) (combine le s)
    | h => h)

tactic: exact noSibling_merge _ _ _
state_before: case h_1
α : Type u_1
le : α → α → Bool
x✝ : Heap α
a✝¹ : α
child✝¹ : Heap α
a✝ : α
child✝ s✝ : Heap α
⊢ NoSibling (merge le (merge le (node a✝¹ child✝¹ (node a✝ child✝ s✝)) (node a✝ child✝ s✝)) (combine le s✝))

tactic: match s with
| nil | node _ _ nil => constructor
| node _ _ (node _ _ s) => rename_i h; exact (h _ _ _ _ _ rfl).elim
state_before: case h_2
α : Type u_1
le : α → α → Bool
s x✝¹ : Heap α
x✝ : ∀ (a : α) (child : Heap α) (a_1 : α) (child_1 s_1 : Heap α), s = node a child (node a_1 child_1 s_1) → False
⊢ NoSibling s

tactic: constructor
state_before: α : Type u_1
le : α → α → Bool
s x✝¹ : Heap α
a✝ : α
child✝ : Heap α
x✝ :
  ∀ (a : α) (child : Heap α) (a_1 : α) (child_1 s : Heap α),
    node a✝ child✝ nil = node a child (node a_1 child_1 s) → False
⊢ NoSibling (node a✝ child✝ nil)

tactic: rename_i h
state_before: α : Type u_1
le : α → α → Bool
s✝ x✝¹ : Heap α
a✝¹ : α
child✝¹ : Heap α
a✝ : α
child✝ s : Heap α
x✝ :
  ∀ (a : α) (child : Heap α) (a_1 : α) (child_1 s_1 : Heap α),
    node a✝¹ child✝¹ (node a✝ child✝ s) = node a child (node a_1 child_1 s_1) → False
⊢ NoSibling (node a✝¹ child✝¹ (node a✝ child✝ s))

tactic: exact (h _ _ _ _ _ rfl).elim
state_before: α : Type u_1
le : α → α → Bool
s✝ x✝ : Heap α
a✝¹ : α
child✝¹ : Heap α
a✝ : α
child✝ s : Heap α
h :
  ∀ (a : α) (child : Heap α) (a_1 : α) (child_1 s_1 : Heap α),
    node a✝¹ child✝¹ (node a✝ child✝ s) = node a child (node a_1 child_1 s_1) → False
⊢ NoSibling (node a✝¹ child✝¹ (node a✝ child✝ s))
Theorem: List.enumFrom_get?
File: Mathlib/Data/List/Basic.lean

tactic: rw [add_right_comm]
state_before: ι : Type ?u.430582
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
a : α
l : List α
m : ℕ
⊢ (fun a => (n + 1 + m, a)) <$> get? l m = (fun a => (n + (m + 1), a)) <$> get? (a :: l) (m + 1)

tactic: rfl
state_before: ι : Type ?u.430582
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
a : α
l : List α
m : ℕ
⊢ (fun a => (n + m + 1, a)) <$> get? l m = (fun a => (n + (m + 1), a)) <$> get? (a :: l) (m + 1)
Theorem: Equiv.Perm.sign_prodExtendRight
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp [eq_of_prodExtendRight_ne hab]
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
a : α
σ : Perm β
x✝¹ : α × β
a' : α
b : β
hab : ↑(prodExtendRight a σ) (a', b) ≠ (a', b)
x✝ : ↑(prodExtendRight a σ) (↑(prodExtendRight a σ) (a', b)) ≠ ↑(prodExtendRight a σ) (a', b)
⊢ (fun ab x => ab.snd) (↑(prodExtendRight a σ) (a', b)) x✝ = ↑σ ((fun ab x => ab.snd) (a', b) hab)

tactic: simpa [eq_of_prodExtendRight_ne hab₁, eq_of_prodExtendRight_ne hab₂] using h
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
a : α
σ : Perm β
x✝¹ x✝ : α × β
a₁ : α
b₁ : β
hab₁ : ↑(prodExtendRight a σ) (a₁, b₁) ≠ (a₁, b₁)
a₂ : α
b₂ : β
hab₂ : ↑(prodExtendRight a σ) (a₂, b₂) ≠ (a₂, b₂)
h : (fun ab x => ab.snd) (a₁, b₁) hab₁ = (fun ab x => ab.snd) (a₂, b₂) hab₂
⊢ (a₁, b₁) = (a₂, b₂)

tactic: simpa
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
a : α
σ : Perm β
y : β
hy : ↑σ y ≠ y
⊢ ↑(prodExtendRight a σ) (a, y) ≠ (a, y)

tactic: simp
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
a : α
σ : Perm β
y : β
hy : ↑σ y ≠ y
⊢ (fun ab x => ab.snd) (a, y) (_ : ↑(prodExtendRight a σ) (a, y) ≠ (a, y)) = y
Theorem: Finset.card_le_card_image₂_right
File: Mathlib/Data/Finset/NAry.lean

tactic: obtain ⟨b, hb⟩ := ht
state_before: α : Type u_2
α' : Type ?u.55415
β : Type u_1
β' : Type ?u.55421
γ : Type u_3
γ' : Type ?u.55427
δ : Type ?u.55430
δ' : Type ?u.55433
ε : Type ?u.55436
ε' : Type ?u.55439
ζ : Type ?u.55442
ζ' : Type ?u.55445
ν : Type ?u.55448
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 : γ
t : Finset β
ht : Finset.Nonempty t
hf : ∀ (b : β), Injective fun a => f a b
⊢ card s ≤ card (image₂ f s t)

tactic: rw [← card_image₂_singleton_right _ (hf b)]
state_before: case intro
α : Type u_2
α' : Type ?u.55415
β : Type u_1
β' : Type ?u.55421
γ : Type u_3
γ' : Type ?u.55427
δ : Type ?u.55430
δ' : Type ?u.55433
ε : Type ?u.55436
ε' : Type ?u.55439
ζ : Type ?u.55442
ζ' : Type ?u.55445
ν : Type ?u.55448
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 : γ
t : Finset β
hf : ∀ (b : β), Injective fun a => f a b
b : β
hb : b ∈ t
⊢ card s ≤ card (image₂ f s t)

tactic: exact card_le_of_subset (image₂_subset_left <| singleton_subset_iff.2 hb)
state_before: case intro
α : Type u_2
α' : Type ?u.55415
β : Type u_1
β' : Type ?u.55421
γ : Type u_3
γ' : Type ?u.55427
δ : Type ?u.55430
δ' : Type ?u.55433
ε : Type ?u.55436
ε' : Type ?u.55439
ζ : Type ?u.55442
ζ' : Type ?u.55445
ν : Type ?u.55448
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 : γ
t : Finset β
hf : ∀ (b : β), Injective fun a => f a b
b : β
hb : b ∈ t
⊢ card (image₂ (fun a => f a) s {b}) ≤ card (image₂ f s t)