import math, json, itertools, platform
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle,Polygon,Wedge,ConnectionPatch

# Pin the first ANCHORS correct source-target pairs, then enumerate every survivor.
ANCHORS = 1  # safely change to 0, 2, 3 or 4
OUT=Path('lab03-visual-output');OUT.mkdir(exist_ok=True)
assert ANCHORS in range(5)
BUILDINGS=['gable house','flat office','twin towers','dome hall']
PERMS_VIS=list(itertools.permutations(range(4)))

def vis_building(ax,index,domain):
    ax.set(xlim=(0,1),ylim=(0,1),aspect='equal');ax.axis('off')
    wall='white' if domain=='X' else ['#e8b28a','#98bec7','#bdafb4','#a8b88b'][index]
    roof='white' if domain=='X' else '#697984';edge='#233b4d';window='white' if domain=='X' else '#eaf5fa'
    def box(x,y,w,h,fc=wall):ax.add_patch(Rectangle((x,y),w,h,facecolor=fc,edgecolor=edge,lw=1.8))
    ax.plot([.05,.95],[.08,.08],color=edge,lw=2)
    if index==0:
        box(.19,.08,.62,.52);ax.add_patch(Polygon([[.12,.6],[.5,.91],[.88,.6]],facecolor=roof,edgecolor=edge,lw=1.8));box(.43,.08,.14,.27,window)
        box(.25,.37,.13,.13,window);box(.62,.37,.13,.13,window)
    elif index==1:
        box(.15,.08,.7,.73);box(.1,.81,.8,.07,roof)
        for x in [.24,.46,.68]:
            for y in [.28,.48,.68]:box(x,y,.09,.08,window)
    elif index==2:
        box(.08,.08,.3,.8);box(.62,.08,.3,.8);box(.38,.25,.24,.17,roof)
        for x in [.17,.71]:
            for y in [.3,.48,.67]:box(x,y,.11,.08,window)
    else:
        box(.16,.08,.68,.45);ax.add_patch(Wedge((.5,.53),.34,0,180,facecolor=roof,edgecolor=edge,lw=1.8));box(.43,.08,.14,.26,window)
    ax.set_title(('line ' if domain=='X' else 'color ')+BUILDINGS[index],fontsize=10)

wrong=(1,2,3,0)
fig,axes=plt.subplots(3,4,figsize=(11.6,8.0))
for i in range(4):
    vis_building(axes[0,i],i,'X');vis_building(axes[1,i],wrong[i],'Y');vis_building(axes[2,i],i,'X')
    for row in [0,1]:
        fig.add_artist(ConnectionPatch((.5,0),(.5,1),coordsA=axes[row,i].transAxes,coordsB=axes[row+1,i].transAxes,arrowstyle='->',color='#c49113',lw=2,shrinkA=6,shrinkB=17))
fig.suptitle('A wrong bijection still returns every building: cycle error = 0; semantic accuracy = 0',fontsize=13)
fig.subplots_adjust(hspace=.6,top=.90);fig.savefig(OUT/'lab03-buildings-cycle.png',dpi=150);plt.show();plt.close(fig)

survivors=[p for p in PERMS_VIS if all(p[i]==i for i in range(ANCHORS))]
fig,axes=plt.subplots(4,6,figsize=(12,7.8))
for ax,p in zip(axes.flat,PERMS_VIS):
    valid=p in survivors;ax.set(xlim=(-.25,1.25),ylim=(-.35,3.45));ax.axis('off')
    for i,j in enumerate(p):ax.plot([0,1],[3-i,3-j],color='#003262' if valid else '#c9cdd1',lw=2,alpha=1 if valid else .6)
    for x in [0,1]:ax.scatter([x]*4,[3,2,1,0],color=['#e39164','#54889b','#a6819a','#879e5a'],s=30,zorder=3)
    for i in range(ANCHORS):ax.scatter([0,1],[3-i,3-i],s=110,facecolors='none',edgecolors='#d69b08',lw=1.5,zorder=4)
    ax.set_title(' '.join(str(i+1) for i in p)+('  kept' if valid else '  ruled out'),fontsize=8,color='#003262' if valid else '#92979d')
fig.suptitle(f'All 24 bijections; {ANCHORS} paired anchor(s) leave {len(survivors)} candidates',fontsize=14)
fig.tight_layout();fig.savefig(OUT/'lab03-anchor-enumeration.png',dpi=160);plt.show();plt.close(fig)

records=[]
for count in range(5):
    keep=[p for p in PERMS_VIS if all(p[i]==i for i in range(count))]
    accuracy=[sum(i==j for i,j in enumerate(p))/4 for p in keep]
    records.append({'anchors':count,'survivors':len(keep),'worst_accuracy':min(accuracy)})
assert [r['survivors'] for r in records]==[24,6,2,1,1]
fig,ax=plt.subplots(figsize=(7.5,3.5));ax.bar([r['anchors'] for r in records],[r['survivors'] for r in records],color='#003262');ax.set(xlabel='Number of paired anchors',ylabel='Surviving bijections',xticks=range(5),title='Extra correspondence removes ambiguity');fig.tight_layout();fig.savefig(OUT/'lab03-anchor-count.png',dpi=160);plt.show();plt.close(fig)
payload={'kind':'finite constructed building images; no CycleGAN training','buildings':BUILDINGS,'anchors':ANCHORS,'survivors':survivors,'counts':records,'wrong_bijection':wrong,'python':platform.python_version()}
(OUT/'lab03-results.json').write_text(json.dumps(payload,indent=2));print(json.dumps(records,indent=2))

[
  {
    "anchors": 0,
    "survivors": 24,
    "worst_accuracy": 0.0
  },
  {
    "anchors": 1,
    "survivors": 6,
    "worst_accuracy": 0.25
  },
  {
    "anchors": 2,
    "survivors": 2,
    "worst_accuracy": 0.5
  },
  {
    "anchors": 3,
    "survivors": 1,
    "worst_accuracy": 1.0
  },
  {
    "anchors": 4,
    "survivors": 1,
    "worst_accuracy": 1.0
  }
]

import itertools
import math
from collections import Counter

SHAPES = ("circle", "square", "triangle", "star")
N = len(SHAPES)
PX = [1/N] * N
PY = [1/N] * N
PERMS = list(itertools.permutations(range(N)))

def inverse(permutation):
    inv = [None] * len(permutation)
    for source, target in enumerate(permutation):
        inv[target] = source
    return tuple(inv)

def pushforward(permutation, source_distribution):
    output = [0.0] * len(permutation)
    for i, j in enumerate(permutation):
        output[j] += source_distribution[i]
    return output

def total_variation(a, b):
    return 0.5 * sum(abs(x-y) for x, y in zip(a,b))

def cycle_error(permutation):
    inv = inverse(permutation)
    wrong = sum(inv[permutation[i]] != i for i in range(len(permutation)))
    wrong += sum(permutation[inv[j]] != j for j in range(len(permutation)))
    return wrong / (2*len(permutation))

def semantic_accuracy(permutation):
    return sum(i == j for i,j in enumerate(permutation))/len(permutation)

accuracies = Counter()
for perm in PERMS:
    assert total_variation(pushforward(perm, PX), PY) < 1e-12
    assert cycle_error(perm) == 0
    accuracies[semantic_accuracy(perm)] += 1
print("bijections:", len(PERMS))
print("All have marginal TV=0 and cycle error=0.")
print("semantic accuracy -> number of equally admissible mappings")
for accuracy, count in sorted(accuracies.items()):
    print(f"{accuracy:.2f} -> {count}")
assert len(PERMS) == math.factorial(4)
assert accuracies[0.0] == 9 and accuracies[1.0] == 1

bijections: 24
All have marginal TV=0 and cycle error=0.
semantic accuracy -> number of equally admissible mappings
0.00 -> 9
0.25 -> 8
0.50 -> 6
1.00 -> 1

wrong_perm = (1, 2, 3, 0)
back = inverse(wrong_perm)
print("source -> translated -> reconstructed")
for i, j in enumerate(wrong_perm):
    print(f"drawing {SHAPES[i]} -> photo {SHAPES[j]} -> drawing {SHAPES[back[j]]}")
print("marginal TV:", total_variation(pushforward(wrong_perm, PX), PY))
print("cycle error:", cycle_error(wrong_perm))
print("semantic accuracy:", semantic_accuracy(wrong_perm))

# 定义域用标签区分，因此可以同时在原目标域上施加 identity。
def G(tagged, perm):
    domain, index = tagged
    return ("Y", perm[index]) if domain == "X" else tagged
def F(tagged, perm):
    domain, index = tagged
    return ("X", inverse(perm)[index]) if domain == "Y" else tagged
for perm in PERMS:
    identity_errors = sum(G(("Y",i),perm) != ("Y",i) for i in range(N))
    identity_errors += sum(F(("X",i),perm) != ("X",i) for i in range(N))
    assert identity_errors == 0
print("All 24 also admit zero identity error on their own domains in this tagged construction.")

source -> translated -> reconstructed
drawing circle -> photo square -> drawing circle
drawing square -> photo triangle -> drawing square
drawing triangle -> photo star -> drawing triangle
drawing star -> photo circle -> drawing star
marginal TV: 0.0
cycle error: 0.0
semantic accuracy: 0.0
All 24 also admit zero identity error on their own domains in this tagged construction.

print("paired anchors | surviving bijections | worst semantic accuracy")
for anchor_count in range(N+1):
    survivors = [p for p in PERMS
                 if all(p[i] == i for i in range(anchor_count))]
    worst = min(semantic_accuracy(p) for p in survivors)
    print(anchor_count, len(survivors), f"{worst:.2f}")
    assert len(survivors) == math.factorial(N-anchor_count)
assert len([p for p in PERMS if p[0] == 0]) == 6

paired anchors | surviving bijections | worst semantic accuracy
0 24 0.00
1 6 0.25
2 2 0.50
3 1 1.00
4 1 1.00

source_freq = [0.4, 0.3, 0.2, 0.1]
for label, target_freq in [("same semantic frequencies", [0.4,0.3,0.2,0.1]),
                           ("reversed domain frequencies", [0.1,0.2,0.3,0.4])]:
    matched = [p for p in PERMS
               if total_variation(pushforward(p, source_freq), target_freq) < 1e-12]
    print(label)
    for perm in matched:
        print("  G =", perm, "cycle error =", cycle_error(perm),
              "semantic accuracy =", semantic_accuracy(perm))
    print("  semantic identity marginal TV =", total_variation(source_freq, target_freq))
    assert len(matched) == 1
print("All exhaustive marginal, inverse, anchor and frequency checks passed.")

same semantic frequencies
  G = (0, 1, 2, 3) cycle error = 0.0 semantic accuracy = 1.0
  semantic identity marginal TV = 0.0
reversed domain frequencies
  G = (3, 2, 1, 0) cycle error = 0.0 semantic accuracy = 0.0
  semantic identity marginal TV = 0.4
All exhaustive marginal, inverse, anchor and frequency checks passed.